{-# OPTIONS_HADDOCK prune #-}
{-# LANGUAGE ForeignFunctionInterface #-}
--------------------------------------------------------------------------------
{-|
Module      :  WxcClassesAL
Copyright   :  Copyright (c) Daan Leijen 2003, 2004
License     :  wxWindows

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.

From the files:

  * @wxc.h@

And contains 2015 methods for 150 classes.
-}
--------------------------------------------------------------------------------
module Graphics.UI.WXCore.WxcClassesAL
    ( -- * Global
     -- ** Misc.
      bitmapDataObjectCreate
     ,bitmapDataObjectCreateEmpty
     ,bitmapDataObjectDelete
     ,bitmapDataObjectGetBitmap
     ,bitmapDataObjectSetBitmap
     ,cFree
     ,colorPickerCtrlCreate
     ,colorPickerCtrlGetColour
     ,colorPickerCtrlSetColour
     ,cursorCreateFromImage
     ,cursorCreateFromStock
     ,cursorCreateLoad
     ,dragIcon
     ,dragListItem
     ,dragString
     ,dragTreeItem
     ,dropSourceCreate
     ,dropSourceDelete
     ,dropSourceDoDragDrop
     ,fileDataObjectAddFile
     ,fileDataObjectCreate
     ,fileDataObjectDelete
     ,fileDataObjectGetFilenames
     ,gcdcCreate
     ,gcdcCreateFromMemory
     ,gcdcCreateFromPrinter
     ,gcdcDelete
     ,gcdcGetGraphicsContext
     ,gcdcSetGraphicsContext
     ,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
     -- ** AuiDefaultTabArt
     ,auiDefaultTabArtClone
     ,auiDefaultTabArtCreate
     ,auiDefaultTabArtDrawBackground
     ,auiDefaultTabArtDrawButton
     ,auiDefaultTabArtDrawTab
     ,auiDefaultTabArtGetBestTabCtrlSize
     ,auiDefaultTabArtGetIndentSize
     ,auiDefaultTabArtGetTabSize
     ,auiDefaultTabArtSetActiveColour
     ,auiDefaultTabArtSetColour
     ,auiDefaultTabArtSetFlags
     ,auiDefaultTabArtSetMeasuringFont
     ,auiDefaultTabArtSetNormalFont
     ,auiDefaultTabArtSetSelectedFont
     ,auiDefaultTabArtSetSizingInfo
     ,auiDefaultTabArtShowDropDown
     -- ** AuiDefaultToolBarArt
     ,auiDefaultToolBarArtClone
     ,auiDefaultToolBarArtCreate
     ,auiDefaultToolBarArtDrawBackground
     ,auiDefaultToolBarArtDrawButton
     ,auiDefaultToolBarArtDrawControlLabel
     ,auiDefaultToolBarArtDrawDropDownButton
     ,auiDefaultToolBarArtDrawGripper
     ,auiDefaultToolBarArtDrawLabel
     ,auiDefaultToolBarArtDrawOverflowButton
     ,auiDefaultToolBarArtDrawPlainBackground
     ,auiDefaultToolBarArtDrawSeparator
     ,auiDefaultToolBarArtGetElementSize
     ,auiDefaultToolBarArtGetFlags
     ,auiDefaultToolBarArtGetFont
     ,auiDefaultToolBarArtGetLabelSize
     ,auiDefaultToolBarArtGetTextOrientation
     ,auiDefaultToolBarArtGetToolSize
     ,auiDefaultToolBarArtSetElementSize
     ,auiDefaultToolBarArtSetFlags
     ,auiDefaultToolBarArtSetFont
     ,auiDefaultToolBarArtSetTextOrientation
     ,auiDefaultToolBarArtShowDropDown
     -- ** AuiDockArt
     ,auiDockArtDrawBackground
     ,auiDockArtDrawBorder
     ,auiDockArtDrawCaption
     ,auiDockArtDrawGripper
     ,auiDockArtDrawPaneButton
     ,auiDockArtDrawSash
     ,auiDockArtGetColour
     ,auiDockArtGetFont
     ,auiDockArtGetMetric
     ,auiDockArtSetColour
     ,auiDockArtSetFont
     ,auiDockArtSetMetric
     -- ** AuiManager
     ,auiManagerAddPane
     ,auiManagerAddPaneByPaneInfo
     ,auiManagerAddPaneByPaneInfoAndDropPosition
     ,auiManagerCreate
     ,auiManagerDelete
     ,auiManagerDetachPane
     ,auiManagerGetAllPanes
     ,auiManagerGetArtProvider
     ,auiManagerGetDockSizeConstraint
     ,auiManagerGetFlags
     ,auiManagerGetManagedWindow
     ,auiManagerGetManager
     ,auiManagerGetPaneByName
     ,auiManagerGetPaneByWindow
     ,auiManagerHideHint
     ,auiManagerInsertPane
     ,auiManagerLoadPaneInfo
     ,auiManagerLoadPerspective
     ,auiManagerSavePaneInfo
     ,auiManagerSavePerspective
     ,auiManagerSetArtProvider
     ,auiManagerSetDockSizeConstraint
     ,auiManagerSetFlags
     ,auiManagerSetManagedWindow
     ,auiManagerShowHint
     ,auiManagerUnInit
     ,auiManagerUpdate
     -- ** AuiManagerEvent
     ,auiManagerEventCanVeto
     ,auiManagerEventCreate
     ,auiManagerEventGetButton
     ,auiManagerEventGetDC
     ,auiManagerEventGetManager
     ,auiManagerEventGetPane
     ,auiManagerEventGetVeto
     ,auiManagerEventSetButton
     ,auiManagerEventSetCanVeto
     ,auiManagerEventSetDC
     ,auiManagerEventSetManager
     ,auiManagerEventSetPane
     ,auiManagerEventVeto
     -- ** AuiNotebook
     ,auiNotebookAddPage
     ,auiNotebookAddPageWithBitmap
     ,auiNotebookAdvanceSelection
     ,auiNotebookChangeSelection
     ,auiNotebookCreate
     ,auiNotebookCreateDefault
     ,auiNotebookCreateFromDefault
     ,auiNotebookDeleteAllPages
     ,auiNotebookDeletePage
     ,auiNotebookGetArtProvider
     ,auiNotebookGetCurrentPage
     ,auiNotebookGetHeightForPageHeight
     ,auiNotebookGetPage
     ,auiNotebookGetPageBitmap
     ,auiNotebookGetPageCount
     ,auiNotebookGetPageIndex
     ,auiNotebookGetPageText
     ,auiNotebookGetPageToolTip
     ,auiNotebookGetSelection
     ,auiNotebookGetTabCtrlHeight
     ,auiNotebookInsertPage
     ,auiNotebookInsertPageWithBitmap
     ,auiNotebookRemovePage
     ,auiNotebookSetArtProvider
     ,auiNotebookSetFont
     ,auiNotebookSetMeasuringFont
     ,auiNotebookSetNormalFont
     ,auiNotebookSetPageBitmap
     ,auiNotebookSetPageImage
     ,auiNotebookSetPageText
     ,auiNotebookSetPageToolTip
     ,auiNotebookSetSelectedFont
     ,auiNotebookSetSelection
     ,auiNotebookSetTabCtrlHeight
     ,auiNotebookSetUniformBitmapSize
     ,auiNotebookShowWindowMenu
     ,auiNotebookSplit
     -- ** AuiNotebookEvent
     ,auiNotebookEventCreate
     ,auiNotebookEventGetDragSource
     -- ** AuiNotebookPage
     ,auiNotebookPageActive
     ,auiNotebookPageBitmap
     ,auiNotebookPageCaption
     ,auiNotebookPageRect
     ,auiNotebookPageTooltip
     ,auiNotebookPageWindow
     -- ** AuiNotebookPageArray
     ,auiNotebookPageArrayCreate
     ,auiNotebookPageArrayDelete
     ,auiNotebookPageArrayGetCount
     ,auiNotebookPageArrayItem
     -- ** AuiPaneInfo
     ,auiPaneInfoBestSize
     ,auiPaneInfoBestSizeXY
     ,auiPaneInfoBottom
     ,auiPaneInfoBottomDockable
     ,auiPaneInfoCaption
     ,auiPaneInfoCaptionVisible
     ,auiPaneInfoCenter
     ,auiPaneInfoCenterPane
     ,auiPaneInfoCentre
     ,auiPaneInfoCentrePane
     ,auiPaneInfoCloseButton
     ,auiPaneInfoCopy
     ,auiPaneInfoCreate
     ,auiPaneInfoCreateDefault
     ,auiPaneInfoDefaultPane
     ,auiPaneInfoDestroyOnClose
     ,auiPaneInfoDirection
     ,auiPaneInfoDock
     ,auiPaneInfoDockFixed
     ,auiPaneInfoDockable
     ,auiPaneInfoFixed
     ,auiPaneInfoFloat
     ,auiPaneInfoFloatable
     ,auiPaneInfoFloatingPosition
     ,auiPaneInfoFloatingPositionXY
     ,auiPaneInfoFloatingSize
     ,auiPaneInfoFloatingSizeXY
     ,auiPaneInfoGripper
     ,auiPaneInfoGripperTop
     ,auiPaneInfoHasBorder
     ,auiPaneInfoHasCaption
     ,auiPaneInfoHasCloseButton
     ,auiPaneInfoHasFlag
     ,auiPaneInfoHasGripper
     ,auiPaneInfoHasGripperTop
     ,auiPaneInfoHasMaximizeButton
     ,auiPaneInfoHasMinimizeButton
     ,auiPaneInfoHasPinButton
     ,auiPaneInfoHide
     ,auiPaneInfoIcon
     ,auiPaneInfoIsBottomDockable
     ,auiPaneInfoIsDockable
     ,auiPaneInfoIsDocked
     ,auiPaneInfoIsFixed
     ,auiPaneInfoIsFloatable
     ,auiPaneInfoIsFloating
     ,auiPaneInfoIsLeftDockable
     ,auiPaneInfoIsMovable
     ,auiPaneInfoIsOk
     ,auiPaneInfoIsResizable
     ,auiPaneInfoIsRightDockable
     ,auiPaneInfoIsShown
     ,auiPaneInfoIsToolbar
     ,auiPaneInfoIsTopDockable
     ,auiPaneInfoLayer
     ,auiPaneInfoLeft
     ,auiPaneInfoLeftDockable
     ,auiPaneInfoMaxSize
     ,auiPaneInfoMaxSizeXY
     ,auiPaneInfoMaximizeButton
     ,auiPaneInfoMinSize
     ,auiPaneInfoMinSizeXY
     ,auiPaneInfoMinimizeButton
     ,auiPaneInfoMovable
     ,auiPaneInfoName
     ,auiPaneInfoPaneBorder
     ,auiPaneInfoPinButton
     ,auiPaneInfoPosition
     ,auiPaneInfoResizable
     ,auiPaneInfoRight
     ,auiPaneInfoRightDockable
     ,auiPaneInfoRow
     ,auiPaneInfoSafeSet
     ,auiPaneInfoSetFlag
     ,auiPaneInfoShow
     ,auiPaneInfoToolbarPane
     ,auiPaneInfoTop
     ,auiPaneInfoTopDockable
     ,auiPaneInfoWindow
     -- ** AuiPaneInfoArray
     ,auiPaneInfoArrayCreate
     ,auiPaneInfoArrayDelete
     ,auiPaneInfoArrayGetCount
     ,auiPaneInfoArrayItem
     -- ** AuiSimpleTabArt
     ,auiSimpleTabArtClone
     ,auiSimpleTabArtCreate
     ,auiSimpleTabArtDrawBackground
     ,auiSimpleTabArtDrawButton
     ,auiSimpleTabArtDrawTab
     ,auiSimpleTabArtGetBestTabCtrlSize
     ,auiSimpleTabArtGetIndentSize
     ,auiSimpleTabArtGetTabSize
     ,auiSimpleTabArtSetActiveColour
     ,auiSimpleTabArtSetColour
     ,auiSimpleTabArtSetFlags
     ,auiSimpleTabArtSetMeasuringFont
     ,auiSimpleTabArtSetNormalFont
     ,auiSimpleTabArtSetSelectedFont
     ,auiSimpleTabArtSetSizingInfo
     ,auiSimpleTabArtShowDropDown
     -- ** AuiTabArt
     ,auiTabArtClone
     ,auiTabArtDrawBackground
     ,auiTabArtDrawButton
     ,auiTabArtDrawTab
     ,auiTabArtGetBestTabCtrlSize
     ,auiTabArtGetIndentSize
     ,auiTabArtGetTabSize
     ,auiTabArtSetActiveColour
     ,auiTabArtSetColour
     ,auiTabArtSetFlags
     ,auiTabArtSetMeasuringFont
     ,auiTabArtSetNormalFont
     ,auiTabArtSetSelectedFont
     ,auiTabArtSetSizingInfo
     -- ** AuiTabContainer
     ,auiTabContainerAddButton
     ,auiTabContainerAddPage
     ,auiTabContainerCreate
     ,auiTabContainerDoShowHide
     ,auiTabContainerGetActivePage
     ,auiTabContainerGetArtProvider
     ,auiTabContainerGetFlags
     ,auiTabContainerGetIdxFromWindow
     ,auiTabContainerGetPage
     ,auiTabContainerGetPageCount
     ,auiTabContainerGetPages
     ,auiTabContainerGetTabOffset
     ,auiTabContainerGetWindowFromIdx
     ,auiTabContainerInsertPage
     ,auiTabContainerIsTabVisible
     ,auiTabContainerMakeTabVisible
     ,auiTabContainerMovePage
     ,auiTabContainerRemoveButton
     ,auiTabContainerRemovePage
     ,auiTabContainerSetActiveColour
     ,auiTabContainerSetActivePage
     ,auiTabContainerSetActivePageByWindow
     ,auiTabContainerSetArtProvider
     ,auiTabContainerSetColour
     ,auiTabContainerSetFlags
     ,auiTabContainerSetMeasuringFont
     ,auiTabContainerSetNoneActive
     ,auiTabContainerSetNormalFont
     ,auiTabContainerSetRect
     ,auiTabContainerSetSelectedFont
     ,auiTabContainerSetTabOffset
     -- ** AuiTabContainerButton
     ,auiTabContainerButtonBitmap
     ,auiTabContainerButtonCurState
     ,auiTabContainerButtonDisBitmap
     ,auiTabContainerButtonId
     ,auiTabContainerButtonLocation
     ,auiTabContainerButtonRect
     -- ** AuiTabCtrl
     ,auiTabCtrlAddButton
     ,auiTabCtrlAddPage
     ,auiTabCtrlDoShowHide
     ,auiTabCtrlGetActivePage
     ,auiTabCtrlGetArtProvider
     ,auiTabCtrlGetFlags
     ,auiTabCtrlGetIdxFromWindow
     ,auiTabCtrlGetPage
     ,auiTabCtrlGetPageCount
     ,auiTabCtrlGetPages
     ,auiTabCtrlGetTabOffset
     ,auiTabCtrlGetWindowFromIdx
     ,auiTabCtrlInsertPage
     ,auiTabCtrlIsTabVisible
     ,auiTabCtrlMakeTabVisible
     ,auiTabCtrlMovePage
     ,auiTabCtrlRemoveButton
     ,auiTabCtrlRemovePage
     ,auiTabCtrlSetActiveColour
     ,auiTabCtrlSetActivePage
     ,auiTabCtrlSetActivePageByWindow
     ,auiTabCtrlSetArtProvider
     ,auiTabCtrlSetColour
     ,auiTabCtrlSetFlags
     ,auiTabCtrlSetMeasuringFont
     ,auiTabCtrlSetNoneActive
     ,auiTabCtrlSetNormalFont
     ,auiTabCtrlSetRect
     ,auiTabCtrlSetSelectedFont
     ,auiTabCtrlSetTabOffset
     -- ** AuiToolBar
     ,auiToolBarAddControl
     ,auiToolBarAddLabel
     ,auiToolBarAddSeparator
     ,auiToolBarAddSpacer
     ,auiToolBarAddStretchSpacer
     ,auiToolBarAddTool
     ,auiToolBarAddToolByBitmap
     ,auiToolBarAddToolByLabel
     ,auiToolBarClear
     ,auiToolBarClearTools
     ,auiToolBarCreate
     ,auiToolBarCreateDefault
     ,auiToolBarCreateFromDefault
     ,auiToolBarDelete
     ,auiToolBarDeleteByIndex
     ,auiToolBarDeleteTool
     ,auiToolBarEnableTool
     ,auiToolBarFindControl
     ,auiToolBarFindTool
     ,auiToolBarFindToolByIndex
     ,auiToolBarFindToolByPosition
     ,auiToolBarGetArtProvider
     ,auiToolBarGetGripperVisible
     ,auiToolBarGetHintSize
     ,auiToolBarGetOverflowVisible
     ,auiToolBarGetToolBarFits
     ,auiToolBarGetToolBitmap
     ,auiToolBarGetToolBitmapSize
     ,auiToolBarGetToolBorderPadding
     ,auiToolBarGetToolCount
     ,auiToolBarGetToolDropDown
     ,auiToolBarGetToolEnabled
     ,auiToolBarGetToolFits
     ,auiToolBarGetToolFitsByIndex
     ,auiToolBarGetToolIndex
     ,auiToolBarGetToolLabel
     ,auiToolBarGetToolLongHelp
     ,auiToolBarGetToolPacking
     ,auiToolBarGetToolPos
     ,auiToolBarGetToolProportion
     ,auiToolBarGetToolRect
     ,auiToolBarGetToolSeparation
     ,auiToolBarGetToolShortHelp
     ,auiToolBarGetToolSticky
     ,auiToolBarGetToolTextOrientation
     ,auiToolBarGetToolToggled
     ,auiToolBarGetWindowStyleFlag
     ,auiToolBarIsPaneValid
     ,auiToolBarRealize
     ,auiToolBarSetArtProvider
     ,auiToolBarSetCustomOverflowItems
     ,auiToolBarSetFont
     ,auiToolBarSetGripperVisible
     ,auiToolBarSetMargins
     ,auiToolBarSetMarginsDetailed
     ,auiToolBarSetMarginsXY
     ,auiToolBarSetOverflowVisible
     ,auiToolBarSetToolBitmap
     ,auiToolBarSetToolBitmapSize
     ,auiToolBarSetToolBorderPadding
     ,auiToolBarSetToolDropDown
     ,auiToolBarSetToolLabel
     ,auiToolBarSetToolLongHelp
     ,auiToolBarSetToolPacking
     ,auiToolBarSetToolProportion
     ,auiToolBarSetToolSeparation
     ,auiToolBarSetToolShortHelp
     ,auiToolBarSetToolSticky
     ,auiToolBarSetToolTextOrientation
     ,auiToolBarSetWindowStyleFlag
     ,auiToolBarToggleTool
     -- ** AuiToolBarArt
     ,auiToolBarArtClone
     ,auiToolBarArtDrawBackground
     ,auiToolBarArtDrawButton
     ,auiToolBarArtDrawControlLabel
     ,auiToolBarArtDrawDropDownButton
     ,auiToolBarArtDrawGripper
     ,auiToolBarArtDrawLabel
     ,auiToolBarArtDrawOverflowButton
     ,auiToolBarArtDrawPlainBackground
     ,auiToolBarArtDrawSeparator
     ,auiToolBarArtGetElementSize
     ,auiToolBarArtGetFlags
     ,auiToolBarArtGetFont
     ,auiToolBarArtGetLabelSize
     ,auiToolBarArtGetTextOrientation
     ,auiToolBarArtGetToolSize
     ,auiToolBarArtSetElementSize
     ,auiToolBarArtSetFlags
     ,auiToolBarArtSetFont
     ,auiToolBarArtSetTextOrientation
     ,auiToolBarArtShowDropDown
     -- ** AuiToolBarEvent
     ,auiToolBarEventGetClickPoint
     ,auiToolBarEventGetItemRect
     ,auiToolBarEventGetToolId
     ,auiToolBarEventIsDropDownClicked
     -- ** AuiToolBarItem
     ,auiToolBarItemAssign
     ,auiToolBarItemCopy
     ,auiToolBarItemCreate
     ,auiToolBarItemCreateDefault
     ,auiToolBarItemGetAlignment
     ,auiToolBarItemGetBitmap
     ,auiToolBarItemGetDisabledBitmap
     ,auiToolBarItemGetHoverBitmap
     ,auiToolBarItemGetId
     ,auiToolBarItemGetKind
     ,auiToolBarItemGetLabel
     ,auiToolBarItemGetLongHelp
     ,auiToolBarItemGetMinSize
     ,auiToolBarItemGetProportion
     ,auiToolBarItemGetShortHelp
     ,auiToolBarItemGetSizerItem
     ,auiToolBarItemGetSpacerPixels
     ,auiToolBarItemGetState
     ,auiToolBarItemGetUserData
     ,auiToolBarItemGetWindow
     ,auiToolBarItemHasDropDown
     ,auiToolBarItemIsActive
     ,auiToolBarItemIsSticky
     ,auiToolBarItemSetActive
     ,auiToolBarItemSetAlignment
     ,auiToolBarItemSetBitmap
     ,auiToolBarItemSetDisabledBitmap
     ,auiToolBarItemSetHasDropDown
     ,auiToolBarItemSetHoverBitmap
     ,auiToolBarItemSetId
     ,auiToolBarItemSetKind
     ,auiToolBarItemSetLabel
     ,auiToolBarItemSetLongHelp
     ,auiToolBarItemSetMinSize
     ,auiToolBarItemSetProportion
     ,auiToolBarItemSetShortHelp
     ,auiToolBarItemSetSizerItem
     ,auiToolBarItemSetSpacerPixels
     ,auiToolBarItemSetState
     ,auiToolBarItemSetSticky
     ,auiToolBarItemSetUserData
     ,auiToolBarItemSetWindow
     -- ** AuiToolBarItemArray
     ,auiToolBarItemArrayCreate
     ,auiToolBarItemArrayDelete
     ,auiToolBarItemArrayGetCount
     ,auiToolBarItemArrayItem
     -- ** 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
     -- ** BitmapToggleButton
     ,bitmapToggleButtonCreate
     ,bitmapToggleButtonEnable
     ,bitmapToggleButtonGetValue
     ,bitmapToggleButtonSetBitmapLabel
     ,bitmapToggleButtonSetValue
     -- ** BookCtrlBase
     ,bookCtrlBaseAddPage
     ,bookCtrlBaseAdvanceSelection
     ,bookCtrlBaseAssignImageList
     ,bookCtrlBaseChangeSelection
     ,bookCtrlBaseCreateFromDefault
     ,bookCtrlBaseDeleteAllPages
     ,bookCtrlBaseDeletePage
     ,bookCtrlBaseFindPage
     ,bookCtrlBaseGetCurrentPage
     ,bookCtrlBaseGetImageList
     ,bookCtrlBaseGetPage
     ,bookCtrlBaseGetPageCount
     ,bookCtrlBaseGetPageImage
     ,bookCtrlBaseGetPageText
     ,bookCtrlBaseGetSelection
     ,bookCtrlBaseHitTest
     ,bookCtrlBaseInsertPage
     ,bookCtrlBaseRemovePage
     ,bookCtrlBaseSetImageList
     ,bookCtrlBaseSetPageImage
     ,bookCtrlBaseSetPageSize
     ,bookCtrlBaseSetPageText
     ,bookCtrlBaseSetSelection
     -- ** BookCtrlEvent
     ,bookCtrlEventCreate
     ,bookCtrlEventGetOldSelection
     ,bookCtrlEventGetSelection
     -- ** BoolProperty
     ,boolPropertyCreate
     -- ** 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
     ,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
     ,comboBoxSetValue
     -- ** 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
     ,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
     ,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
     ,dcSetDeviceClippingRegion
     ,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
     -- ** DateProperty
     ,datePropertyCreate
     -- ** 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
     -- ** 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
     -- ** FileInputStream
     ,fileInputStreamCreate
     ,fileInputStreamDelete
     ,fileInputStreamIsOk
     -- ** FileOutputStream
     ,fileOutputStreamCreate
     ,fileOutputStreamDelete
     ,fileOutputStreamIsOk
     -- ** FileProperty
     ,filePropertyCreate
     -- ** 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
     -- ** FloatProperty
     ,floatPropertyCreate
     -- ** 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
     -- ** GLCanvas
     ,glCanvasCreate
     ,glCanvasIsDisplaySupported
     ,glCanvasIsExtensionSupported
     ,glCanvasSetColour
     ,glCanvasSetCurrent
     ,glCanvasSwapBuffers
     -- ** GLContext
     ,glContextCreate
     ,glContextCreateFromNull
     ,glContextSetCurrent
     -- ** Gauge
     ,gaugeCreate
     ,gaugeGetBezelFace
     ,gaugeGetRange
     ,gaugeGetShadowWidth
     ,gaugeGetValue
     ,gaugeSetBezelFace
     ,gaugeSetRange
     ,gaugeSetShadowWidth
     ,gaugeSetValue
     -- ** GenericDragImage
     ,genericDragImageCreate
     ,genericDragImageDoDrawImage
     ,genericDragImageGetImageRect
     ,genericDragImageUpdateBackingFromWindow
     -- ** GraphicsBrush
     ,graphicsBrushCreate
     ,graphicsBrushDelete
     -- ** GraphicsContext
     ,graphicsContextClip
     ,graphicsContextClipByRectangle
     ,graphicsContextConcatTransform
     ,graphicsContextCreate
     ,graphicsContextCreateDefaultMatrix
     ,graphicsContextCreateFromMemory
     ,graphicsContextCreateFromNative
     ,graphicsContextCreateFromNativeWindow
     ,graphicsContextCreateFromPrinter
     ,graphicsContextCreateFromWindow
     ,graphicsContextCreateMatrix
     ,graphicsContextCreatePath
     ,graphicsContextDelete
     ,graphicsContextDrawBitmap
     ,graphicsContextDrawEllipse
     ,graphicsContextDrawIcon
     ,graphicsContextDrawLines
     ,graphicsContextDrawPath
     ,graphicsContextDrawRectangle
     ,graphicsContextDrawRoundedRectangle
     ,graphicsContextDrawText
     ,graphicsContextDrawTextWithAngle
     ,graphicsContextFillPath
     ,graphicsContextGetNativeContext
     ,graphicsContextGetTextExtent
     ,graphicsContextPopState
     ,graphicsContextPushState
     ,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
     ,graphicsPathDelete
     ,graphicsPathGetBox
     ,graphicsPathGetCurrentPoint
     ,graphicsPathGetNativePath
     ,graphicsPathMoveToPoint
     ,graphicsPathTransform
     ,graphicsPathUnGetNativePath
     -- ** GraphicsPen
     ,graphicsPenCreate
     ,graphicsPenDelete
     -- ** GraphicsRenderer
     ,graphicsRendererCreateContext
     ,graphicsRendererCreateContextFromNativeContext
     ,graphicsRendererCreateContextFromNativeWindow
     ,graphicsRendererCreateContextFromWindow
     ,graphicsRendererCreatePath
     ,graphicsRendererDelete
     ,graphicsRendererGetDefaultRenderer
     -- ** Grid
     ,gridAppendCols
     ,gridAppendRows
     ,gridAutoSize
     ,gridAutoSizeColumn
     ,gridAutoSizeColumns
     ,gridAutoSizeRow
     ,gridAutoSizeRows
     ,gridBeginBatch
     ,gridBlockToDeviceRect
     ,gridCanDragColSize
     ,gridCanDragGridSize
     ,gridCanDragRowSize
     ,gridCanEnableCellControl
     ,gridCellToRect
     ,gridClearGrid
     ,gridClearSelection
     ,gridCreate
     ,gridCreateGrid
     ,gridDeleteCols
     ,gridDeleteRows
     ,gridDisableCellEditControl
     ,gridDisableDragColSize
     ,gridDisableDragGridSize
     ,gridDisableDragRowSize
     ,gridDrawAllGridLines
     ,gridDrawCell
     ,gridDrawCellBorder
     ,gridDrawCellHighlight
     ,gridDrawColLabel
     ,gridDrawColLabels
     ,gridDrawGridSpace
     ,gridDrawRowLabel
     ,gridDrawRowLabels
     ,gridDrawTextRectangle
     ,gridEnableCellEditControl
     ,gridEnableDragColSize
     ,gridEnableDragGridSize
     ,gridEnableDragRowSize
     ,gridEnableEditing
     ,gridEnableGridLines
     ,gridEndBatch
     ,gridGetBatchCount
     ,gridGetCellAlignment
     ,gridGetCellBackgroundColour
     ,gridGetCellEditor
     ,gridGetCellFont
     ,gridGetCellHighlightColour
     ,gridGetCellRenderer
     ,gridGetCellSize
     ,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
     ,gridProcessTableMessage
     ,gridRegisterDataType
     ,gridSaveEditControlValue
     ,gridSelectAll
     ,gridSelectBlock
     ,gridSelectCol
     ,gridSelectRow
     ,gridSetCellAlignment
     ,gridSetCellBackgroundColour
     ,gridSetCellEditor
     ,gridSetCellFont
     ,gridSetCellHighlightColour
     ,gridSetCellRenderer
     ,gridSetCellSize
     ,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
     -- ** GridCellAutoWrapStringRenderer
     ,gridCellAutoWrapStringRendererCtor
     -- ** 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
     -- ** GridCellNumberRenderer
     ,gridCellNumberRendererCtor
     -- ** 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
     -- ** HyperlinkCtrl
     ,hyperlinkCtrlCreate
     ,hyperlinkCtrlGetHoverColour
     ,hyperlinkCtrlGetNormalColour
     ,hyperlinkCtrlGetURL
     ,hyperlinkCtrlGetVisited
     ,hyperlinkCtrlGetVisitedColour
     ,hyperlinkCtrlSetHoverColour
     ,hyperlinkCtrlSetNormalColour
     ,hyperlinkCtrlSetURL
     ,hyperlinkCtrlSetVisited
     ,hyperlinkCtrlSetVisitedColour
     -- ** 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
     ,imageCopy
     ,imageCountColours
     ,imageCreateDefault
     ,imageCreateFromBitmap
     ,imageCreateFromByteString
     ,imageCreateFromData
     ,imageCreateFromDataEx
     ,imageCreateFromFile
     ,imageCreateFromLazyByteString
     ,imageCreateSized
     ,imageDelete
     ,imageDestroy
     ,imageGetBlue
     ,imageGetData
     ,imageGetGreen
     ,imageGetHeight
     ,imageGetMaskBlue
     ,imageGetMaskGreen
     ,imageGetMaskRed
     ,imageGetOption
     ,imageGetOptionInt
     ,imageGetRed
     ,imageGetSubImage
     ,imageGetType
     ,imageGetWidth
     ,imageHasMask
     ,imageHasOption
     ,imageInitialize
     ,imageInitializeFromData
     ,imageIsOk
     ,imageLoadFile
     ,imageLoadStream
     ,imageMirror
     ,imagePaste
     ,imageReplace
     ,imageRescale
     ,imageRescaleEx
     ,imageRotate
     ,imageRotate90
     ,imageSaveFile
     ,imageSaveStream
     ,imageScale
     ,imageScaleEx
     ,imageSetData
     ,imageSetDataAndSize
     ,imageSetMask
     ,imageSetMaskColour
     ,imageSetOption
     ,imageSetOptionInt
     ,imageSetRGB
     ,imageSetType
     -- ** 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
     -- ** IntProperty
     ,intPropertyCreate
     -- ** 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
     ,listCtrlGetItemFont
     ,listCtrlGetItemPosition
     ,listCtrlGetItemPosition2
     ,listCtrlGetItemRect
     ,listCtrlGetItemSpacing
     ,listCtrlGetItemState
     ,listCtrlGetItemText
     ,listCtrlGetNextItem
     ,listCtrlGetSelectedItemCount
     ,listCtrlGetTextColour
     ,listCtrlGetTopItem
     ,listCtrlHitTest
     ,listCtrlInsertColumn
     ,listCtrlInsertColumnFromInfo
     ,listCtrlInsertItem
     ,listCtrlInsertItemWithData
     ,listCtrlInsertItemWithImage
     ,listCtrlInsertItemWithLabel
     ,listCtrlIsVirtual
     ,listCtrlRefreshItem
     ,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
     ,logSetVerbose
     ,logSuspend
     -- ** LogChain
     ,logChainCreate
     ,logChainDelete
     ,logChainGetOldLog
     ,logChainIsPassingMessages
     ,logChainPassMessages
     ,logChainSetLog
     -- ** LogNull
     ,logNullCreate
     -- ** LogStderr
     ,logStderrCreate
     ,logStderrCreateStdOut
     -- ** LogTextCtrl
     ,logTextCtrlCreate
     -- ** LogWindow
     ,logWindowCreate
     ,logWindowGetFrame
    ) where

import Prelude hiding (id, last, length, lines, max, min, show)
import qualified Data.ByteString as B (ByteString, useAsCStringLen)
import qualified Data.ByteString.Lazy as LB (ByteString, length, unpack)
import Graphics.UI.WXCore.WxcTypes hiding (rect, rgb, rgba, sz)
import Graphics.UI.WXCore.WxcClassTypes

-- | 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: (@auiDefaultTabArtClone obj@).
auiDefaultTabArtClone :: AuiDefaultTabArt  a ->  IO (AuiTabArt  ())
auiDefaultTabArtClone _obj 
  = withObjectResult $
    withObjectRef "auiDefaultTabArtClone" _obj $ \cobj__obj -> 
    wxAuiDefaultTabArt_Clone cobj__obj  
foreign import ccall "wxAuiDefaultTabArt_Clone" wxAuiDefaultTabArt_Clone :: Ptr (TAuiDefaultTabArt a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiDefaultTabArtCreate@).
auiDefaultTabArtCreate ::  IO (AuiDefaultTabArt  ())
auiDefaultTabArtCreate 
  = withObjectResult $
    wxAuiDefaultTabArt_Create 
foreign import ccall "wxAuiDefaultTabArt_Create" wxAuiDefaultTabArt_Create :: IO (Ptr (TAuiDefaultTabArt ()))

-- | usage: (@auiDefaultTabArtDrawBackground obj dc wnd rect@).
auiDefaultTabArtDrawBackground :: AuiDefaultTabArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiDefaultTabArtDrawBackground _obj _dc _wnd _rect 
  = withObjectRef "auiDefaultTabArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultTabArt_DrawBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiDefaultTabArt_DrawBackground" wxAuiDefaultTabArt_DrawBackground :: Ptr (TAuiDefaultTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiDefaultTabArtDrawButton obj dc wnd inRect bitmapId buttonState orientation outRect@).
auiDefaultTabArtDrawButton :: AuiDefaultTabArt  a -> DC  b -> Window  c -> Rect -> Int -> Int -> Int -> Rect ->  IO ()
auiDefaultTabArtDrawButton _obj _dc _wnd _inRect bitmapId buttonState orientation _outRect 
  = withObjectRef "auiDefaultTabArtDrawButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _inRect $ \cobj__inRect -> 
    withWxRectPtr _outRect $ \cobj__outRect -> 
    wxAuiDefaultTabArt_DrawButton cobj__obj  cobj__dc  cobj__wnd  cobj__inRect  (toCInt bitmapId)  (toCInt buttonState)  (toCInt orientation)  cobj__outRect  
foreign import ccall "wxAuiDefaultTabArt_DrawButton" wxAuiDefaultTabArt_DrawButton :: Ptr (TAuiDefaultTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> CInt -> CInt -> CInt -> Ptr (TWxRect h) -> IO ()

-- | usage: (@auiDefaultTabArtDrawTab obj dc wnd pane inRect closeButtonState outTabRect outButtonRect xExtent@).
auiDefaultTabArtDrawTab :: AuiDefaultTabArt  a -> DC  b -> Window  c -> AuiNotebookPage  d -> Rect -> Int -> Rect -> Rect -> Ptr CInt ->  IO ()
auiDefaultTabArtDrawTab _obj _dc _wnd _pane _inRect closeButtonState _outTabRect _outButtonRect xExtent 
  = withObjectRef "auiDefaultTabArtDrawTab" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _pane $ \cobj__pane -> 
    withWxRectPtr _inRect $ \cobj__inRect -> 
    withWxRectPtr _outTabRect $ \cobj__outTabRect -> 
    withWxRectPtr _outButtonRect $ \cobj__outButtonRect -> 
    wxAuiDefaultTabArt_DrawTab cobj__obj  cobj__dc  cobj__wnd  cobj__pane  cobj__inRect  (toCInt closeButtonState)  cobj__outTabRect  cobj__outButtonRect  xExtent  
foreign import ccall "wxAuiDefaultTabArt_DrawTab" wxAuiDefaultTabArt_DrawTab :: Ptr (TAuiDefaultTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiNotebookPage d) -> Ptr (TWxRect e) -> CInt -> Ptr (TWxRect g) -> Ptr (TWxRect h) -> Ptr CInt -> IO ()

-- | usage: (@auiDefaultTabArtGetBestTabCtrlSize obj wnd pages widthheight@).
auiDefaultTabArtGetBestTabCtrlSize :: AuiDefaultTabArt  a -> Window  b -> AuiNotebookPageArray  c -> Size ->  IO Int
auiDefaultTabArtGetBestTabCtrlSize _obj _wnd _pages _widthheight 
  = withIntResult $
    withObjectRef "auiDefaultTabArtGetBestTabCtrlSize" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _pages $ \cobj__pages -> 
    wxAuiDefaultTabArt_GetBestTabCtrlSize cobj__obj  cobj__wnd  cobj__pages  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiDefaultTabArt_GetBestTabCtrlSize" wxAuiDefaultTabArt_GetBestTabCtrlSize :: Ptr (TAuiDefaultTabArt a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPageArray c) -> CInt -> CInt -> IO CInt

-- | usage: (@auiDefaultTabArtGetIndentSize obj@).
auiDefaultTabArtGetIndentSize :: AuiDefaultTabArt  a ->  IO Int
auiDefaultTabArtGetIndentSize _obj 
  = withIntResult $
    withObjectRef "auiDefaultTabArtGetIndentSize" _obj $ \cobj__obj -> 
    wxAuiDefaultTabArt_GetIndentSize cobj__obj  
foreign import ccall "wxAuiDefaultTabArt_GetIndentSize" wxAuiDefaultTabArt_GetIndentSize :: Ptr (TAuiDefaultTabArt a) -> IO CInt

-- | usage: (@auiDefaultTabArtGetTabSize obj dc wnd caption bitmap active closeButtonState xExtent@).
auiDefaultTabArtGetTabSize :: AuiDefaultTabArt  a -> DC  b -> Window  c -> String -> Bitmap  e -> Bool -> Int -> Ptr CInt ->  IO (Size)
auiDefaultTabArtGetTabSize _obj _dc _wnd _caption _bitmap active closeButtonState xExtent 
  = withWxSizeResult $
    withObjectRef "auiDefaultTabArtGetTabSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withStringPtr _caption $ \cobj__caption -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiDefaultTabArt_GetTabSize cobj__obj  cobj__dc  cobj__wnd  cobj__caption  cobj__bitmap  (toCBool active)  (toCInt closeButtonState)  xExtent  
foreign import ccall "wxAuiDefaultTabArt_GetTabSize" wxAuiDefaultTabArt_GetTabSize :: Ptr (TAuiDefaultTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxString d) -> Ptr (TBitmap e) -> CBool -> CInt -> Ptr CInt -> IO (Ptr (TWxSize ()))

-- | usage: (@auiDefaultTabArtSetActiveColour obj colour@).
auiDefaultTabArtSetActiveColour :: AuiDefaultTabArt  a -> Color ->  IO ()
auiDefaultTabArtSetActiveColour _obj _colour 
  = withObjectRef "auiDefaultTabArtSetActiveColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiDefaultTabArt_SetActiveColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiDefaultTabArt_SetActiveColour" wxAuiDefaultTabArt_SetActiveColour :: Ptr (TAuiDefaultTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiDefaultTabArtSetColour obj colour@).
auiDefaultTabArtSetColour :: AuiDefaultTabArt  a -> Color ->  IO ()
auiDefaultTabArtSetColour _obj _colour 
  = withObjectRef "auiDefaultTabArtSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiDefaultTabArt_SetColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiDefaultTabArt_SetColour" wxAuiDefaultTabArt_SetColour :: Ptr (TAuiDefaultTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiDefaultTabArtSetFlags obj flags@).
auiDefaultTabArtSetFlags :: AuiDefaultTabArt  a -> Int ->  IO ()
auiDefaultTabArtSetFlags _obj _flags 
  = withObjectRef "auiDefaultTabArtSetFlags" _obj $ \cobj__obj -> 
    wxAuiDefaultTabArt_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiDefaultTabArt_SetFlags" wxAuiDefaultTabArt_SetFlags :: Ptr (TAuiDefaultTabArt a) -> CInt -> IO ()

-- | usage: (@auiDefaultTabArtSetMeasuringFont obj font@).
auiDefaultTabArtSetMeasuringFont :: AuiDefaultTabArt  a -> Font  b ->  IO ()
auiDefaultTabArtSetMeasuringFont _obj _font 
  = withObjectRef "auiDefaultTabArtSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiDefaultTabArt_SetMeasuringFont cobj__obj  cobj__font  
foreign import ccall "wxAuiDefaultTabArt_SetMeasuringFont" wxAuiDefaultTabArt_SetMeasuringFont :: Ptr (TAuiDefaultTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiDefaultTabArtSetNormalFont obj font@).
auiDefaultTabArtSetNormalFont :: AuiDefaultTabArt  a -> Font  b ->  IO ()
auiDefaultTabArtSetNormalFont _obj _font 
  = withObjectRef "auiDefaultTabArtSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiDefaultTabArt_SetNormalFont cobj__obj  cobj__font  
foreign import ccall "wxAuiDefaultTabArt_SetNormalFont" wxAuiDefaultTabArt_SetNormalFont :: Ptr (TAuiDefaultTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiDefaultTabArtSetSelectedFont obj font@).
auiDefaultTabArtSetSelectedFont :: AuiDefaultTabArt  a -> Font  b ->  IO ()
auiDefaultTabArtSetSelectedFont _obj _font 
  = withObjectRef "auiDefaultTabArtSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiDefaultTabArt_SetSelectedFont cobj__obj  cobj__font  
foreign import ccall "wxAuiDefaultTabArt_SetSelectedFont" wxAuiDefaultTabArt_SetSelectedFont :: Ptr (TAuiDefaultTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiDefaultTabArtSetSizingInfo obj widthheight tabCount@).
auiDefaultTabArtSetSizingInfo :: AuiDefaultTabArt  a -> Size -> Int ->  IO ()
auiDefaultTabArtSetSizingInfo _obj _widthheight tabCount 
  = withObjectRef "auiDefaultTabArtSetSizingInfo" _obj $ \cobj__obj -> 
    wxAuiDefaultTabArt_SetSizingInfo cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt tabCount)  
foreign import ccall "wxAuiDefaultTabArt_SetSizingInfo" wxAuiDefaultTabArt_SetSizingInfo :: Ptr (TAuiDefaultTabArt a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@auiDefaultTabArtShowDropDown obj wnd items activeIdx@).
auiDefaultTabArtShowDropDown :: AuiDefaultTabArt  a -> Window  b -> AuiNotebookPageArray  c -> Int ->  IO Int
auiDefaultTabArtShowDropDown _obj _wnd _items activeIdx 
  = withIntResult $
    withObjectRef "auiDefaultTabArtShowDropDown" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _items $ \cobj__items -> 
    wxAuiDefaultTabArt_ShowDropDown cobj__obj  cobj__wnd  cobj__items  (toCInt activeIdx)  
foreign import ccall "wxAuiDefaultTabArt_ShowDropDown" wxAuiDefaultTabArt_ShowDropDown :: Ptr (TAuiDefaultTabArt a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPageArray c) -> CInt -> IO CInt

-- | usage: (@auiDefaultToolBarArtClone obj@).
auiDefaultToolBarArtClone :: AuiDefaultToolBarArt  a ->  IO (AuiToolBarArt  ())
auiDefaultToolBarArtClone _obj 
  = withObjectResult $
    withObjectRef "auiDefaultToolBarArtClone" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_Clone cobj__obj  
foreign import ccall "wxAuiDefaultToolBarArt_Clone" wxAuiDefaultToolBarArt_Clone :: Ptr (TAuiDefaultToolBarArt a) -> IO (Ptr (TAuiToolBarArt ()))

-- | usage: (@auiDefaultToolBarArtCreate@).
auiDefaultToolBarArtCreate ::  IO (AuiDefaultToolBarArt  ())
auiDefaultToolBarArtCreate 
  = withObjectResult $
    wxAuiDefaultToolBarArt_Create 
foreign import ccall "wxAuiDefaultToolBarArt_Create" wxAuiDefaultToolBarArt_Create :: IO (Ptr (TAuiDefaultToolBarArt ()))

-- | usage: (@auiDefaultToolBarArtDrawBackground obj dc wnd rect@).
auiDefaultToolBarArtDrawBackground :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiDefaultToolBarArtDrawBackground _obj _dc _wnd _rect 
  = withObjectRef "auiDefaultToolBarArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawBackground" wxAuiDefaultToolBarArt_DrawBackground :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawButton obj dc wnd item rect@).
auiDefaultToolBarArtDrawButton :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiDefaultToolBarArtDrawButton _obj _dc _wnd _item _rect 
  = withObjectRef "auiDefaultToolBarArtDrawButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawButton cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawButton" wxAuiDefaultToolBarArt_DrawButton :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawControlLabel obj dc wnd item rect@).
auiDefaultToolBarArtDrawControlLabel :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiDefaultToolBarArtDrawControlLabel _obj _dc _wnd _item _rect 
  = withObjectRef "auiDefaultToolBarArtDrawControlLabel" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawControlLabel cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawControlLabel" wxAuiDefaultToolBarArt_DrawControlLabel :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawDropDownButton obj dc wnd item rect@).
auiDefaultToolBarArtDrawDropDownButton :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiDefaultToolBarArtDrawDropDownButton _obj _dc _wnd _item _rect 
  = withObjectRef "auiDefaultToolBarArtDrawDropDownButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawDropDownButton cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawDropDownButton" wxAuiDefaultToolBarArt_DrawDropDownButton :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawGripper obj dc wnd rect@).
auiDefaultToolBarArtDrawGripper :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiDefaultToolBarArtDrawGripper _obj _dc _wnd _rect 
  = withObjectRef "auiDefaultToolBarArtDrawGripper" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawGripper cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawGripper" wxAuiDefaultToolBarArt_DrawGripper :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawLabel obj dc wnd item rect@).
auiDefaultToolBarArtDrawLabel :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiDefaultToolBarArtDrawLabel _obj _dc _wnd _item _rect 
  = withObjectRef "auiDefaultToolBarArtDrawLabel" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawLabel cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawLabel" wxAuiDefaultToolBarArt_DrawLabel :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawOverflowButton obj dc wnd rect state@).
auiDefaultToolBarArtDrawOverflowButton :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> Rect -> Int ->  IO ()
auiDefaultToolBarArtDrawOverflowButton _obj _dc _wnd _rect state 
  = withObjectRef "auiDefaultToolBarArtDrawOverflowButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawOverflowButton cobj__obj  cobj__dc  cobj__wnd  cobj__rect  (toCInt state)  
foreign import ccall "wxAuiDefaultToolBarArt_DrawOverflowButton" wxAuiDefaultToolBarArt_DrawOverflowButton :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> CInt -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawPlainBackground obj dc wnd rect@).
auiDefaultToolBarArtDrawPlainBackground :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiDefaultToolBarArtDrawPlainBackground _obj _dc _wnd _rect 
  = withObjectRef "auiDefaultToolBarArtDrawPlainBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawPlainBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawPlainBackground" wxAuiDefaultToolBarArt_DrawPlainBackground :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiDefaultToolBarArtDrawSeparator obj dc wnd rect@).
auiDefaultToolBarArtDrawSeparator :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiDefaultToolBarArtDrawSeparator _obj _dc _wnd _rect 
  = withObjectRef "auiDefaultToolBarArtDrawSeparator" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDefaultToolBarArt_DrawSeparator cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiDefaultToolBarArt_DrawSeparator" wxAuiDefaultToolBarArt_DrawSeparator :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiDefaultToolBarArtGetElementSize obj element@).
auiDefaultToolBarArtGetElementSize :: AuiDefaultToolBarArt  a -> Int ->  IO Int
auiDefaultToolBarArtGetElementSize _obj element 
  = withIntResult $
    withObjectRef "auiDefaultToolBarArtGetElementSize" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_GetElementSize cobj__obj  (toCInt element)  
foreign import ccall "wxAuiDefaultToolBarArt_GetElementSize" wxAuiDefaultToolBarArt_GetElementSize :: Ptr (TAuiDefaultToolBarArt a) -> CInt -> IO CInt

-- | usage: (@auiDefaultToolBarArtGetFlags obj@).
auiDefaultToolBarArtGetFlags :: AuiDefaultToolBarArt  a ->  IO Int
auiDefaultToolBarArtGetFlags _obj 
  = withIntResult $
    withObjectRef "auiDefaultToolBarArtGetFlags" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_GetFlags cobj__obj  
foreign import ccall "wxAuiDefaultToolBarArt_GetFlags" wxAuiDefaultToolBarArt_GetFlags :: Ptr (TAuiDefaultToolBarArt a) -> IO CInt

-- | usage: (@auiDefaultToolBarArtGetFont obj@).
auiDefaultToolBarArtGetFont :: AuiDefaultToolBarArt  a ->  IO (Font  ())
auiDefaultToolBarArtGetFont _obj 
  = withManagedFontResult $
    withObjectRef "auiDefaultToolBarArtGetFont" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_GetFont cobj__obj  
foreign import ccall "wxAuiDefaultToolBarArt_GetFont" wxAuiDefaultToolBarArt_GetFont :: Ptr (TAuiDefaultToolBarArt a) -> IO (Ptr (TFont ()))

-- | usage: (@auiDefaultToolBarArtGetLabelSize obj dc wnd item@).
auiDefaultToolBarArtGetLabelSize :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d ->  IO (Size)
auiDefaultToolBarArtGetLabelSize _obj _dc _wnd _item 
  = withWxSizeResult $
    withObjectRef "auiDefaultToolBarArtGetLabelSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    wxAuiDefaultToolBarArt_GetLabelSize cobj__obj  cobj__dc  cobj__wnd  cobj__item  
foreign import ccall "wxAuiDefaultToolBarArt_GetLabelSize" wxAuiDefaultToolBarArt_GetLabelSize :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiDefaultToolBarArtGetTextOrientation obj@).
auiDefaultToolBarArtGetTextOrientation :: AuiDefaultToolBarArt  a ->  IO Int
auiDefaultToolBarArtGetTextOrientation _obj 
  = withIntResult $
    withObjectRef "auiDefaultToolBarArtGetTextOrientation" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_GetTextOrientation cobj__obj  
foreign import ccall "wxAuiDefaultToolBarArt_GetTextOrientation" wxAuiDefaultToolBarArt_GetTextOrientation :: Ptr (TAuiDefaultToolBarArt a) -> IO CInt

-- | usage: (@auiDefaultToolBarArtGetToolSize obj dc wnd item@).
auiDefaultToolBarArtGetToolSize :: AuiDefaultToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d ->  IO (Size)
auiDefaultToolBarArtGetToolSize _obj _dc _wnd _item 
  = withWxSizeResult $
    withObjectRef "auiDefaultToolBarArtGetToolSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    wxAuiDefaultToolBarArt_GetToolSize cobj__obj  cobj__dc  cobj__wnd  cobj__item  
foreign import ccall "wxAuiDefaultToolBarArt_GetToolSize" wxAuiDefaultToolBarArt_GetToolSize :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiDefaultToolBarArtSetElementSize obj elementid size@).
auiDefaultToolBarArtSetElementSize :: AuiDefaultToolBarArt  a -> Int -> Int ->  IO ()
auiDefaultToolBarArtSetElementSize _obj elementid size 
  = withObjectRef "auiDefaultToolBarArtSetElementSize" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_SetElementSize cobj__obj  (toCInt elementid)  (toCInt size)  
foreign import ccall "wxAuiDefaultToolBarArt_SetElementSize" wxAuiDefaultToolBarArt_SetElementSize :: Ptr (TAuiDefaultToolBarArt a) -> CInt -> CInt -> IO ()

-- | usage: (@auiDefaultToolBarArtSetFlags obj flags@).
auiDefaultToolBarArtSetFlags :: AuiDefaultToolBarArt  a -> Int ->  IO ()
auiDefaultToolBarArtSetFlags _obj _flags 
  = withObjectRef "auiDefaultToolBarArtSetFlags" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiDefaultToolBarArt_SetFlags" wxAuiDefaultToolBarArt_SetFlags :: Ptr (TAuiDefaultToolBarArt a) -> CInt -> IO ()

-- | usage: (@auiDefaultToolBarArtSetFont obj font@).
auiDefaultToolBarArtSetFont :: AuiDefaultToolBarArt  a -> Font  b ->  IO ()
auiDefaultToolBarArtSetFont _obj _font 
  = withObjectRef "auiDefaultToolBarArtSetFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiDefaultToolBarArt_SetFont cobj__obj  cobj__font  
foreign import ccall "wxAuiDefaultToolBarArt_SetFont" wxAuiDefaultToolBarArt_SetFont :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiDefaultToolBarArtSetTextOrientation obj orientation@).
auiDefaultToolBarArtSetTextOrientation :: AuiDefaultToolBarArt  a -> Int ->  IO ()
auiDefaultToolBarArtSetTextOrientation _obj orientation 
  = withObjectRef "auiDefaultToolBarArtSetTextOrientation" _obj $ \cobj__obj -> 
    wxAuiDefaultToolBarArt_SetTextOrientation cobj__obj  (toCInt orientation)  
foreign import ccall "wxAuiDefaultToolBarArt_SetTextOrientation" wxAuiDefaultToolBarArt_SetTextOrientation :: Ptr (TAuiDefaultToolBarArt a) -> CInt -> IO ()

-- | usage: (@auiDefaultToolBarArtShowDropDown obj wnd items@).
auiDefaultToolBarArtShowDropDown :: AuiDefaultToolBarArt  a -> Window  b -> AuiToolBarItemArray  c ->  IO Int
auiDefaultToolBarArtShowDropDown _obj _wnd _items 
  = withIntResult $
    withObjectRef "auiDefaultToolBarArtShowDropDown" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _items $ \cobj__items -> 
    wxAuiDefaultToolBarArt_ShowDropDown cobj__obj  cobj__wnd  cobj__items  
foreign import ccall "wxAuiDefaultToolBarArt_ShowDropDown" wxAuiDefaultToolBarArt_ShowDropDown :: Ptr (TAuiDefaultToolBarArt a) -> Ptr (TWindow b) -> Ptr (TAuiToolBarItemArray c) -> IO CInt

-- | usage: (@auiDockArtDrawBackground obj dc window orientation rect@).
auiDockArtDrawBackground :: AuiDockArt  a -> DC  b -> Window  c -> Int -> Rect ->  IO ()
auiDockArtDrawBackground _obj _dc _window orientation _rect 
  = withObjectRef "auiDockArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDockArt_DrawBackground cobj__obj  cobj__dc  cobj__window  (toCInt orientation)  cobj__rect  
foreign import ccall "wxAuiDockArt_DrawBackground" wxAuiDockArt_DrawBackground :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> CInt -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDockArtDrawBorder obj dc window rect pane@).
auiDockArtDrawBorder :: AuiDockArt  a -> DC  b -> Window  c -> Rect -> AuiPaneInfo  e ->  IO ()
auiDockArtDrawBorder _obj _dc _window _rect _pane 
  = withObjectRef "auiDockArtDrawBorder" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiDockArt_DrawBorder cobj__obj  cobj__dc  cobj__window  cobj__rect  cobj__pane  
foreign import ccall "wxAuiDockArt_DrawBorder" wxAuiDockArt_DrawBorder :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> Ptr (TAuiPaneInfo e) -> IO ()

-- | usage: (@auiDockArtDrawCaption obj dc window text rect pane@).
auiDockArtDrawCaption :: AuiDockArt  a -> DC  b -> Window  c -> String -> Rect -> AuiPaneInfo  f ->  IO ()
auiDockArtDrawCaption _obj _dc _window _text _rect _pane 
  = withObjectRef "auiDockArtDrawCaption" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withStringPtr _text $ \cobj__text -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiDockArt_DrawCaption cobj__obj  cobj__dc  cobj__window  cobj__text  cobj__rect  cobj__pane  
foreign import ccall "wxAuiDockArt_DrawCaption" wxAuiDockArt_DrawCaption :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxString d) -> Ptr (TWxRect e) -> Ptr (TAuiPaneInfo f) -> IO ()

-- | usage: (@auiDockArtDrawGripper obj dc window rect pane@).
auiDockArtDrawGripper :: AuiDockArt  a -> DC  b -> Window  c -> Rect -> AuiPaneInfo  e ->  IO ()
auiDockArtDrawGripper _obj _dc _window _rect _pane 
  = withObjectRef "auiDockArtDrawGripper" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiDockArt_DrawGripper cobj__obj  cobj__dc  cobj__window  cobj__rect  cobj__pane  
foreign import ccall "wxAuiDockArt_DrawGripper" wxAuiDockArt_DrawGripper :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> Ptr (TAuiPaneInfo e) -> IO ()

-- | usage: (@auiDockArtDrawPaneButton obj dc window button buttonstate rect pane@).
auiDockArtDrawPaneButton :: AuiDockArt  a -> DC  b -> Window  c -> Int -> Int -> Rect -> AuiPaneInfo  g ->  IO ()
auiDockArtDrawPaneButton _obj _dc _window button buttonstate _rect _pane 
  = withObjectRef "auiDockArtDrawPaneButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiDockArt_DrawPaneButton cobj__obj  cobj__dc  cobj__window  (toCInt button)  (toCInt buttonstate)  cobj__rect  cobj__pane  
foreign import ccall "wxAuiDockArt_DrawPaneButton" wxAuiDockArt_DrawPaneButton :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> CInt -> CInt -> Ptr (TWxRect f) -> Ptr (TAuiPaneInfo g) -> IO ()

-- | usage: (@auiDockArtDrawSash obj dc window orientation rect@).
auiDockArtDrawSash :: AuiDockArt  a -> DC  b -> Window  c -> Int -> Rect ->  IO ()
auiDockArtDrawSash _obj _dc _window orientation _rect 
  = withObjectRef "auiDockArtDrawSash" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _window $ \cobj__window -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiDockArt_DrawSash cobj__obj  cobj__dc  cobj__window  (toCInt orientation)  cobj__rect  
foreign import ccall "wxAuiDockArt_DrawSash" wxAuiDockArt_DrawSash :: Ptr (TAuiDockArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> CInt -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiDockArtGetColour obj id@).
auiDockArtGetColour :: AuiDockArt  a -> Id ->  IO (Color)
auiDockArtGetColour _obj id 
  = withManagedColourResult $
    withObjectRef "auiDockArtGetColour" _obj $ \cobj__obj -> 
    wxAuiDockArt_GetColour cobj__obj  (toCInt id)  
foreign import ccall "wxAuiDockArt_GetColour" wxAuiDockArt_GetColour :: Ptr (TAuiDockArt a) -> CInt -> IO (Ptr (TColour ()))

-- | usage: (@auiDockArtGetFont obj id@).
auiDockArtGetFont :: AuiDockArt  a -> Id ->  IO (Font  ())
auiDockArtGetFont _obj id 
  = withManagedFontResult $
    withObjectRef "auiDockArtGetFont" _obj $ \cobj__obj -> 
    wxAuiDockArt_GetFont cobj__obj  (toCInt id)  
foreign import ccall "wxAuiDockArt_GetFont" wxAuiDockArt_GetFont :: Ptr (TAuiDockArt a) -> CInt -> IO (Ptr (TFont ()))

-- | usage: (@auiDockArtGetMetric obj id@).
auiDockArtGetMetric :: AuiDockArt  a -> Id ->  IO Int
auiDockArtGetMetric _obj id 
  = withIntResult $
    withObjectRef "auiDockArtGetMetric" _obj $ \cobj__obj -> 
    wxAuiDockArt_GetMetric cobj__obj  (toCInt id)  
foreign import ccall "wxAuiDockArt_GetMetric" wxAuiDockArt_GetMetric :: Ptr (TAuiDockArt a) -> CInt -> IO CInt

-- | usage: (@auiDockArtSetColour obj id colour@).
auiDockArtSetColour :: AuiDockArt  a -> Id -> Color ->  IO ()
auiDockArtSetColour _obj id _colour 
  = withObjectRef "auiDockArtSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiDockArt_SetColour cobj__obj  (toCInt id)  cobj__colour  
foreign import ccall "wxAuiDockArt_SetColour" wxAuiDockArt_SetColour :: Ptr (TAuiDockArt a) -> CInt -> Ptr (TColour c) -> IO ()

-- | usage: (@auiDockArtSetFont obj id font@).
auiDockArtSetFont :: AuiDockArt  a -> Id -> Font  c ->  IO ()
auiDockArtSetFont _obj id _font 
  = withObjectRef "auiDockArtSetFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiDockArt_SetFont cobj__obj  (toCInt id)  cobj__font  
foreign import ccall "wxAuiDockArt_SetFont" wxAuiDockArt_SetFont :: Ptr (TAuiDockArt a) -> CInt -> Ptr (TFont c) -> IO ()

-- | usage: (@auiDockArtSetMetric obj id newval@).
auiDockArtSetMetric :: AuiDockArt  a -> Id -> Int ->  IO ()
auiDockArtSetMetric _obj id newval 
  = withObjectRef "auiDockArtSetMetric" _obj $ \cobj__obj -> 
    wxAuiDockArt_SetMetric cobj__obj  (toCInt id)  (toCInt newval)  
foreign import ccall "wxAuiDockArt_SetMetric" wxAuiDockArt_SetMetric :: Ptr (TAuiDockArt a) -> CInt -> CInt -> IO ()

-- | usage: (@auiManagerAddPane obj window direction caption@).
auiManagerAddPane :: AuiManager  a -> Window  b -> Int -> String ->  IO Bool
auiManagerAddPane _obj _window _direction _caption 
  = withBoolResult $
    withObjectRef "auiManagerAddPane" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    withStringPtr _caption $ \cobj__caption -> 
    wxAuiManager_AddPane cobj__obj  cobj__window  (toCInt _direction)  cobj__caption  
foreign import ccall "wxAuiManager_AddPane" wxAuiManager_AddPane :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> CInt -> Ptr (TWxString d) -> IO CBool

-- | usage: (@auiManagerAddPaneByPaneInfo obj window paneinfo@).
auiManagerAddPaneByPaneInfo :: AuiManager  a -> Window  b -> AuiPaneInfo  c ->  IO Bool
auiManagerAddPaneByPaneInfo _obj _window _paneinfo 
  = withBoolResult $
    withObjectRef "auiManagerAddPaneByPaneInfo" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    withObjectPtr _paneinfo $ \cobj__paneinfo -> 
    wxAuiManager_AddPaneByPaneInfo cobj__obj  cobj__window  cobj__paneinfo  
foreign import ccall "wxAuiManager_AddPaneByPaneInfo" wxAuiManager_AddPaneByPaneInfo :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> Ptr (TAuiPaneInfo c) -> IO CBool

-- | usage: (@auiManagerAddPaneByPaneInfoAndDropPosition obj window paneinfo xy@).
auiManagerAddPaneByPaneInfoAndDropPosition :: AuiManager  a -> Window  b -> AuiPaneInfo  c -> Point ->  IO Bool
auiManagerAddPaneByPaneInfoAndDropPosition _obj _window _paneinfo xy 
  = withBoolResult $
    withObjectRef "auiManagerAddPaneByPaneInfoAndDropPosition" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    withObjectPtr _paneinfo $ \cobj__paneinfo -> 
    wxAuiManager_AddPaneByPaneInfoAndDropPosition cobj__obj  cobj__window  cobj__paneinfo  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiManager_AddPaneByPaneInfoAndDropPosition" wxAuiManager_AddPaneByPaneInfoAndDropPosition :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> Ptr (TAuiPaneInfo c) -> CInt -> CInt -> IO CBool

-- | usage: (@auiManagerCreate managedwnd flags@).
auiManagerCreate :: Window  a -> Int ->  IO (AuiManager  ())
auiManagerCreate _managedwnd _flags 
  = withObjectResult $
    withObjectPtr _managedwnd $ \cobj__managedwnd -> 
    wxAuiManager_Create cobj__managedwnd  (toCInt _flags)  
foreign import ccall "wxAuiManager_Create" wxAuiManager_Create :: Ptr (TWindow a) -> CInt -> IO (Ptr (TAuiManager ()))

-- | usage: (@auiManagerDelete obj@).
auiManagerDelete :: AuiManager  a ->  IO ()
auiManagerDelete
  = objectDelete


-- | usage: (@auiManagerDetachPane obj window@).
auiManagerDetachPane :: AuiManager  a -> Window  b ->  IO Bool
auiManagerDetachPane _obj _window 
  = withBoolResult $
    withObjectRef "auiManagerDetachPane" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    wxAuiManager_DetachPane cobj__obj  cobj__window  
foreign import ccall "wxAuiManager_DetachPane" wxAuiManager_DetachPane :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@auiManagerEventCanVeto obj@).
auiManagerEventCanVeto :: AuiManagerEvent  a ->  IO Bool
auiManagerEventCanVeto _obj 
  = withBoolResult $
    withObjectRef "auiManagerEventCanVeto" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_CanVeto cobj__obj  
foreign import ccall "wxAuiManagerEvent_CanVeto" wxAuiManagerEvent_CanVeto :: Ptr (TAuiManagerEvent a) -> IO CBool

-- | usage: (@auiManagerEventCreate wxtype@).
auiManagerEventCreate :: Int ->  IO (AuiManagerEvent  ())
auiManagerEventCreate wxtype 
  = withObjectResult $
    wxAuiManagerEvent_Create (toCInt wxtype)  
foreign import ccall "wxAuiManagerEvent_Create" wxAuiManagerEvent_Create :: CInt -> IO (Ptr (TAuiManagerEvent ()))

-- | usage: (@auiManagerEventGetButton obj@).
auiManagerEventGetButton :: AuiManagerEvent  a ->  IO Int
auiManagerEventGetButton _obj 
  = withIntResult $
    withObjectRef "auiManagerEventGetButton" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_GetButton cobj__obj  
foreign import ccall "wxAuiManagerEvent_GetButton" wxAuiManagerEvent_GetButton :: Ptr (TAuiManagerEvent a) -> IO CInt

-- | usage: (@auiManagerEventGetDC obj@).
auiManagerEventGetDC :: AuiManagerEvent  a ->  IO (DC  ())
auiManagerEventGetDC _obj 
  = withObjectResult $
    withObjectRef "auiManagerEventGetDC" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_GetDC cobj__obj  
foreign import ccall "wxAuiManagerEvent_GetDC" wxAuiManagerEvent_GetDC :: Ptr (TAuiManagerEvent a) -> IO (Ptr (TDC ()))

-- | usage: (@auiManagerEventGetManager obj@).
auiManagerEventGetManager :: AuiManagerEvent  a ->  IO (AuiManager  ())
auiManagerEventGetManager _obj 
  = withObjectResult $
    withObjectRef "auiManagerEventGetManager" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_GetManager cobj__obj  
foreign import ccall "wxAuiManagerEvent_GetManager" wxAuiManagerEvent_GetManager :: Ptr (TAuiManagerEvent a) -> IO (Ptr (TAuiManager ()))

-- | usage: (@auiManagerEventGetPane obj@).
auiManagerEventGetPane :: AuiManagerEvent  a ->  IO (AuiPaneInfo  ())
auiManagerEventGetPane _obj 
  = withObjectResult $
    withObjectRef "auiManagerEventGetPane" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_GetPane cobj__obj  
foreign import ccall "wxAuiManagerEvent_GetPane" wxAuiManagerEvent_GetPane :: Ptr (TAuiManagerEvent a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiManagerEventGetVeto obj@).
auiManagerEventGetVeto :: AuiManagerEvent  a ->  IO Bool
auiManagerEventGetVeto _obj 
  = withBoolResult $
    withObjectRef "auiManagerEventGetVeto" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_GetVeto cobj__obj  
foreign import ccall "wxAuiManagerEvent_GetVeto" wxAuiManagerEvent_GetVeto :: Ptr (TAuiManagerEvent a) -> IO CBool

-- | usage: (@auiManagerEventSetButton obj button@).
auiManagerEventSetButton :: AuiManagerEvent  a -> Int ->  IO ()
auiManagerEventSetButton _obj button 
  = withObjectRef "auiManagerEventSetButton" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_SetButton cobj__obj  (toCInt button)  
foreign import ccall "wxAuiManagerEvent_SetButton" wxAuiManagerEvent_SetButton :: Ptr (TAuiManagerEvent a) -> CInt -> IO ()

-- | usage: (@auiManagerEventSetCanVeto obj canveto@).
auiManagerEventSetCanVeto :: AuiManagerEvent  a -> Bool ->  IO ()
auiManagerEventSetCanVeto _obj canveto 
  = withObjectRef "auiManagerEventSetCanVeto" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_SetCanVeto cobj__obj  (toCBool canveto)  
foreign import ccall "wxAuiManagerEvent_SetCanVeto" wxAuiManagerEvent_SetCanVeto :: Ptr (TAuiManagerEvent a) -> CBool -> IO ()

-- | usage: (@auiManagerEventSetDC obj pdc@).
auiManagerEventSetDC :: AuiManagerEvent  a -> DC  b ->  IO ()
auiManagerEventSetDC _obj _pdc 
  = withObjectRef "auiManagerEventSetDC" _obj $ \cobj__obj -> 
    withObjectPtr _pdc $ \cobj__pdc -> 
    wxAuiManagerEvent_SetDC cobj__obj  cobj__pdc  
foreign import ccall "wxAuiManagerEvent_SetDC" wxAuiManagerEvent_SetDC :: Ptr (TAuiManagerEvent a) -> Ptr (TDC b) -> IO ()

-- | usage: (@auiManagerEventSetManager obj manager@).
auiManagerEventSetManager :: AuiManagerEvent  a -> AuiManager  b ->  IO ()
auiManagerEventSetManager _obj _manager 
  = withObjectRef "auiManagerEventSetManager" _obj $ \cobj__obj -> 
    withObjectPtr _manager $ \cobj__manager -> 
    wxAuiManagerEvent_SetManager cobj__obj  cobj__manager  
foreign import ccall "wxAuiManagerEvent_SetManager" wxAuiManagerEvent_SetManager :: Ptr (TAuiManagerEvent a) -> Ptr (TAuiManager b) -> IO ()

-- | usage: (@auiManagerEventSetPane obj pane@).
auiManagerEventSetPane :: AuiManagerEvent  a -> AuiPaneInfo  b ->  IO ()
auiManagerEventSetPane _obj _pane 
  = withObjectRef "auiManagerEventSetPane" _obj $ \cobj__obj -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiManagerEvent_SetPane cobj__obj  cobj__pane  
foreign import ccall "wxAuiManagerEvent_SetPane" wxAuiManagerEvent_SetPane :: Ptr (TAuiManagerEvent a) -> Ptr (TAuiPaneInfo b) -> IO ()

-- | usage: (@auiManagerEventVeto obj veto@).
auiManagerEventVeto :: AuiManagerEvent  a -> Bool ->  IO ()
auiManagerEventVeto _obj veto 
  = withObjectRef "auiManagerEventVeto" _obj $ \cobj__obj -> 
    wxAuiManagerEvent_Veto cobj__obj  (toCBool veto)  
foreign import ccall "wxAuiManagerEvent_Veto" wxAuiManagerEvent_Veto :: Ptr (TAuiManagerEvent a) -> CBool -> IO ()

-- | usage: (@auiManagerGetAllPanes obj@).
auiManagerGetAllPanes :: AuiManager  a ->  IO (AuiPaneInfoArray  ())
auiManagerGetAllPanes _obj 
  = withObjectResult $
    withObjectRef "auiManagerGetAllPanes" _obj $ \cobj__obj -> 
    wxAuiManager_GetAllPanes cobj__obj  
foreign import ccall "wxAuiManager_GetAllPanes" wxAuiManager_GetAllPanes :: Ptr (TAuiManager a) -> IO (Ptr (TAuiPaneInfoArray ()))

-- | usage: (@auiManagerGetArtProvider obj@).
auiManagerGetArtProvider :: AuiManager  a ->  IO (AuiDockArt  ())
auiManagerGetArtProvider _obj 
  = withObjectResult $
    withObjectRef "auiManagerGetArtProvider" _obj $ \cobj__obj -> 
    wxAuiManager_GetArtProvider cobj__obj  
foreign import ccall "wxAuiManager_GetArtProvider" wxAuiManager_GetArtProvider :: Ptr (TAuiManager a) -> IO (Ptr (TAuiDockArt ()))

-- | usage: (@auiManagerGetDockSizeConstraint obj widthpct heightpct@).
auiManagerGetDockSizeConstraint :: AuiManager  a -> Ptr Double -> Ptr Double ->  IO ()
auiManagerGetDockSizeConstraint _obj _widthpct _heightpct 
  = withObjectRef "auiManagerGetDockSizeConstraint" _obj $ \cobj__obj -> 
    wxAuiManager_GetDockSizeConstraint cobj__obj  _widthpct  _heightpct  
foreign import ccall "wxAuiManager_GetDockSizeConstraint" wxAuiManager_GetDockSizeConstraint :: Ptr (TAuiManager a) -> Ptr Double -> Ptr Double -> IO ()

-- | usage: (@auiManagerGetFlags obj@).
auiManagerGetFlags :: AuiManager  a ->  IO Int
auiManagerGetFlags _obj 
  = withIntResult $
    withObjectRef "auiManagerGetFlags" _obj $ \cobj__obj -> 
    wxAuiManager_GetFlags cobj__obj  
foreign import ccall "wxAuiManager_GetFlags" wxAuiManager_GetFlags :: Ptr (TAuiManager a) -> IO CInt

-- | usage: (@auiManagerGetManagedWindow obj@).
auiManagerGetManagedWindow :: AuiManager  a ->  IO (Window  ())
auiManagerGetManagedWindow _obj 
  = withObjectResult $
    withObjectRef "auiManagerGetManagedWindow" _obj $ \cobj__obj -> 
    wxAuiManager_GetManagedWindow cobj__obj  
foreign import ccall "wxAuiManager_GetManagedWindow" wxAuiManager_GetManagedWindow :: Ptr (TAuiManager a) -> IO (Ptr (TWindow ()))

-- | usage: (@auiManagerGetManager window@).
auiManagerGetManager :: Window  a ->  IO (AuiManager  ())
auiManagerGetManager _window 
  = withObjectResult $
    withObjectPtr _window $ \cobj__window -> 
    wxAuiManager_GetManager cobj__window  
foreign import ccall "wxAuiManager_GetManager" wxAuiManager_GetManager :: Ptr (TWindow a) -> IO (Ptr (TAuiManager ()))

-- | usage: (@auiManagerGetPaneByName obj name@).
auiManagerGetPaneByName :: AuiManager  a -> String ->  IO (AuiPaneInfo  ())
auiManagerGetPaneByName _obj _name 
  = withObjectResult $
    withObjectRef "auiManagerGetPaneByName" _obj $ \cobj__obj -> 
    withStringPtr _name $ \cobj__name -> 
    wxAuiManager_GetPaneByName cobj__obj  cobj__name  
foreign import ccall "wxAuiManager_GetPaneByName" wxAuiManager_GetPaneByName :: Ptr (TAuiManager a) -> Ptr (TWxString b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiManagerGetPaneByWindow obj window@).
auiManagerGetPaneByWindow :: AuiManager  a -> Window  b ->  IO (AuiPaneInfo  ())
auiManagerGetPaneByWindow _obj _window 
  = withObjectResult $
    withObjectRef "auiManagerGetPaneByWindow" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    wxAuiManager_GetPaneByWindow cobj__obj  cobj__window  
foreign import ccall "wxAuiManager_GetPaneByWindow" wxAuiManager_GetPaneByWindow :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiManagerHideHint obj@).
auiManagerHideHint :: AuiManager  a ->  IO ()
auiManagerHideHint _obj 
  = withObjectRef "auiManagerHideHint" _obj $ \cobj__obj -> 
    wxAuiManager_HideHint cobj__obj  
foreign import ccall "wxAuiManager_HideHint" wxAuiManager_HideHint :: Ptr (TAuiManager a) -> IO ()

-- | usage: (@auiManagerInsertPane obj window insertlocation insertlevel@).
auiManagerInsertPane :: AuiManager  a -> Window  b -> AuiPaneInfo  c -> Int ->  IO Bool
auiManagerInsertPane _obj _window _insertlocation _insertlevel 
  = withBoolResult $
    withObjectRef "auiManagerInsertPane" _obj $ \cobj__obj -> 
    withObjectPtr _window $ \cobj__window -> 
    withObjectPtr _insertlocation $ \cobj__insertlocation -> 
    wxAuiManager_InsertPane cobj__obj  cobj__window  cobj__insertlocation  (toCInt _insertlevel)  
foreign import ccall "wxAuiManager_InsertPane" wxAuiManager_InsertPane :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> Ptr (TAuiPaneInfo c) -> CInt -> IO CBool

-- | usage: (@auiManagerLoadPaneInfo obj panepart pane@).
auiManagerLoadPaneInfo :: AuiManager  a -> String -> AuiPaneInfo  c ->  IO ()
auiManagerLoadPaneInfo _obj _panepart _pane 
  = withObjectRef "auiManagerLoadPaneInfo" _obj $ \cobj__obj -> 
    withStringPtr _panepart $ \cobj__panepart -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiManager_LoadPaneInfo cobj__obj  cobj__panepart  cobj__pane  
foreign import ccall "wxAuiManager_LoadPaneInfo" wxAuiManager_LoadPaneInfo :: Ptr (TAuiManager a) -> Ptr (TWxString b) -> Ptr (TAuiPaneInfo c) -> IO ()

-- | usage: (@auiManagerLoadPerspective obj perspective update@).
auiManagerLoadPerspective :: AuiManager  a -> String -> Bool ->  IO Bool
auiManagerLoadPerspective _obj _perspective update 
  = withBoolResult $
    withObjectRef "auiManagerLoadPerspective" _obj $ \cobj__obj -> 
    withStringPtr _perspective $ \cobj__perspective -> 
    wxAuiManager_LoadPerspective cobj__obj  cobj__perspective  (toCBool update)  
foreign import ccall "wxAuiManager_LoadPerspective" wxAuiManager_LoadPerspective :: Ptr (TAuiManager a) -> Ptr (TWxString b) -> CBool -> IO CBool

-- | usage: (@auiManagerSavePaneInfo obj pane@).
auiManagerSavePaneInfo :: AuiManager  a -> AuiPaneInfo  b ->  IO (String)
auiManagerSavePaneInfo _obj _pane 
  = withManagedStringResult $
    withObjectRef "auiManagerSavePaneInfo" _obj $ \cobj__obj -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiManager_SavePaneInfo cobj__obj  cobj__pane  
foreign import ccall "wxAuiManager_SavePaneInfo" wxAuiManager_SavePaneInfo :: Ptr (TAuiManager a) -> Ptr (TAuiPaneInfo b) -> IO (Ptr (TWxString ()))

-- | usage: (@auiManagerSavePerspective obj@).
auiManagerSavePerspective :: AuiManager  a ->  IO (String)
auiManagerSavePerspective _obj 
  = withManagedStringResult $
    withObjectRef "auiManagerSavePerspective" _obj $ \cobj__obj -> 
    wxAuiManager_SavePerspective cobj__obj  
foreign import ccall "wxAuiManager_SavePerspective" wxAuiManager_SavePerspective :: Ptr (TAuiManager a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiManagerSetArtProvider obj artprovider@).
auiManagerSetArtProvider :: AuiManager  a -> AuiDockArt  b ->  IO ()
auiManagerSetArtProvider _obj _artprovider 
  = withObjectRef "auiManagerSetArtProvider" _obj $ \cobj__obj -> 
    withObjectPtr _artprovider $ \cobj__artprovider -> 
    wxAuiManager_SetArtProvider cobj__obj  cobj__artprovider  
foreign import ccall "wxAuiManager_SetArtProvider" wxAuiManager_SetArtProvider :: Ptr (TAuiManager a) -> Ptr (TAuiDockArt b) -> IO ()

-- | usage: (@auiManagerSetDockSizeConstraint obj widthpct heightpct@).
auiManagerSetDockSizeConstraint :: AuiManager  a -> Double -> Double ->  IO ()
auiManagerSetDockSizeConstraint _obj widthpct heightpct 
  = withObjectRef "auiManagerSetDockSizeConstraint" _obj $ \cobj__obj -> 
    wxAuiManager_SetDockSizeConstraint cobj__obj  widthpct  heightpct  
foreign import ccall "wxAuiManager_SetDockSizeConstraint" wxAuiManager_SetDockSizeConstraint :: Ptr (TAuiManager a) -> Double -> Double -> IO ()

-- | usage: (@auiManagerSetFlags obj flags@).
auiManagerSetFlags :: AuiManager  a -> Int ->  IO ()
auiManagerSetFlags _obj flags 
  = withObjectRef "auiManagerSetFlags" _obj $ \cobj__obj -> 
    wxAuiManager_SetFlags cobj__obj  (toCInt flags)  
foreign import ccall "wxAuiManager_SetFlags" wxAuiManager_SetFlags :: Ptr (TAuiManager a) -> CInt -> IO ()

-- | usage: (@auiManagerSetManagedWindow obj managedwnd@).
auiManagerSetManagedWindow :: AuiManager  a -> Window  b ->  IO ()
auiManagerSetManagedWindow _obj _managedwnd 
  = withObjectRef "auiManagerSetManagedWindow" _obj $ \cobj__obj -> 
    withObjectPtr _managedwnd $ \cobj__managedwnd -> 
    wxAuiManager_SetManagedWindow cobj__obj  cobj__managedwnd  
foreign import ccall "wxAuiManager_SetManagedWindow" wxAuiManager_SetManagedWindow :: Ptr (TAuiManager a) -> Ptr (TWindow b) -> IO ()

-- | usage: (@auiManagerShowHint obj rect@).
auiManagerShowHint :: AuiManager  a -> Rect ->  IO ()
auiManagerShowHint _obj _rect 
  = withObjectRef "auiManagerShowHint" _obj $ \cobj__obj -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiManager_ShowHint cobj__obj  cobj__rect  
foreign import ccall "wxAuiManager_ShowHint" wxAuiManager_ShowHint :: Ptr (TAuiManager a) -> Ptr (TWxRect b) -> IO ()

-- | usage: (@auiManagerUnInit obj@).
auiManagerUnInit :: AuiManager  a ->  IO ()
auiManagerUnInit _obj 
  = withObjectRef "auiManagerUnInit" _obj $ \cobj__obj -> 
    wxAuiManager_UnInit cobj__obj  
foreign import ccall "wxAuiManager_UnInit" wxAuiManager_UnInit :: Ptr (TAuiManager a) -> IO ()

-- | usage: (@auiManagerUpdate obj@).
auiManagerUpdate :: AuiManager  a ->  IO ()
auiManagerUpdate _obj 
  = withObjectRef "auiManagerUpdate" _obj $ \cobj__obj -> 
    wxAuiManager_Update cobj__obj  
foreign import ccall "wxAuiManager_Update" wxAuiManager_Update :: Ptr (TAuiManager a) -> IO ()

-- | usage: (@auiNotebookAddPage obj page text select imageId@).
auiNotebookAddPage :: AuiNotebook  a -> Window  b -> String -> Bool -> Int ->  IO Bool
auiNotebookAddPage _obj _page _text select imageId 
  = withBoolResult $
    withObjectRef "auiNotebookAddPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _text $ \cobj__text -> 
    wxAuiNotebook_AddPage cobj__obj  cobj__page  cobj__text  (toCBool select)  (toCInt imageId)  
foreign import ccall "wxAuiNotebook_AddPage" wxAuiNotebook_AddPage :: Ptr (TAuiNotebook a) -> Ptr (TWindow b) -> Ptr (TWxString c) -> CBool -> CInt -> IO CBool

-- | usage: (@auiNotebookAddPageWithBitmap obj page caption select bitmap@).
auiNotebookAddPageWithBitmap :: AuiNotebook  a -> Window  b -> String -> Bool -> Bitmap  e ->  IO Bool
auiNotebookAddPageWithBitmap _obj _page _caption select _bitmap 
  = withBoolResult $
    withObjectRef "auiNotebookAddPageWithBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _caption $ \cobj__caption -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiNotebook_AddPageWithBitmap cobj__obj  cobj__page  cobj__caption  (toCBool select)  cobj__bitmap  
foreign import ccall "wxAuiNotebook_AddPageWithBitmap" wxAuiNotebook_AddPageWithBitmap :: Ptr (TAuiNotebook a) -> Ptr (TWindow b) -> Ptr (TWxString c) -> CBool -> Ptr (TBitmap e) -> IO CBool

-- | usage: (@auiNotebookAdvanceSelection obj forward@).
auiNotebookAdvanceSelection :: AuiNotebook  a -> Bool ->  IO ()
auiNotebookAdvanceSelection _obj forward 
  = withObjectRef "auiNotebookAdvanceSelection" _obj $ \cobj__obj -> 
    wxAuiNotebook_AdvanceSelection cobj__obj  (toCBool forward)  
foreign import ccall "wxAuiNotebook_AdvanceSelection" wxAuiNotebook_AdvanceSelection :: Ptr (TAuiNotebook a) -> CBool -> IO ()

-- | usage: (@auiNotebookChangeSelection obj n@).
auiNotebookChangeSelection :: AuiNotebook  a -> Int ->  IO Int
auiNotebookChangeSelection _obj n 
  = withIntResult $
    withObjectRef "auiNotebookChangeSelection" _obj $ \cobj__obj -> 
    wxAuiNotebook_ChangeSelection cobj__obj  (toCInt n)  
foreign import ccall "wxAuiNotebook_ChangeSelection" wxAuiNotebook_ChangeSelection :: Ptr (TAuiNotebook a) -> CInt -> IO CInt

-- | usage: (@auiNotebookCreate parent id xy widthheight style@).
auiNotebookCreate :: Window  a -> Id -> Point -> Size -> Int ->  IO (AuiNotebook  ())
auiNotebookCreate _parent id xy _widthheight style 
  = withObjectResult $
    withObjectPtr _parent $ \cobj__parent -> 
    wxAuiNotebook_Create cobj__parent  (toCInt id)  (toCIntPointX xy) (toCIntPointY xy)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt style)  
foreign import ccall "wxAuiNotebook_Create" wxAuiNotebook_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TAuiNotebook ()))

-- | usage: (@auiNotebookCreateDefault@).
auiNotebookCreateDefault ::  IO (AuiNotebook  ())
auiNotebookCreateDefault 
  = withObjectResult $
    wxAuiNotebook_CreateDefault 
foreign import ccall "wxAuiNotebook_CreateDefault" wxAuiNotebook_CreateDefault :: IO (Ptr (TAuiNotebook ()))

-- | usage: (@auiNotebookCreateFromDefault obj parent id xy widthheight style@).
auiNotebookCreateFromDefault :: AuiNotebook  a -> Window  b -> Id -> Point -> Size -> Int ->  IO Bool
auiNotebookCreateFromDefault _obj _parent id xy _widthheight style 
  = withBoolResult $
    withObjectRef "auiNotebookCreateFromDefault" _obj $ \cobj__obj -> 
    withObjectPtr _parent $ \cobj__parent -> 
    wxAuiNotebook_CreateFromDefault cobj__obj  cobj__parent  (toCInt id)  (toCIntPointX xy) (toCIntPointY xy)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt style)  
foreign import ccall "wxAuiNotebook_CreateFromDefault" wxAuiNotebook_CreateFromDefault :: Ptr (TAuiNotebook a) -> Ptr (TWindow b) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@auiNotebookDeleteAllPages obj@).
auiNotebookDeleteAllPages :: AuiNotebook  a ->  IO Bool
auiNotebookDeleteAllPages _obj 
  = withBoolResult $
    withObjectRef "auiNotebookDeleteAllPages" _obj $ \cobj__obj -> 
    wxAuiNotebook_DeleteAllPages cobj__obj  
foreign import ccall "wxAuiNotebook_DeleteAllPages" wxAuiNotebook_DeleteAllPages :: Ptr (TAuiNotebook a) -> IO CBool

-- | usage: (@auiNotebookDeletePage obj page@).
auiNotebookDeletePage :: AuiNotebook  a -> Int ->  IO Bool
auiNotebookDeletePage _obj page 
  = withBoolResult $
    withObjectRef "auiNotebookDeletePage" _obj $ \cobj__obj -> 
    wxAuiNotebook_DeletePage cobj__obj  (toCInt page)  
foreign import ccall "wxAuiNotebook_DeletePage" wxAuiNotebook_DeletePage :: Ptr (TAuiNotebook a) -> CInt -> IO CBool

-- | usage: (@auiNotebookEventCreate commandtype winid@).
auiNotebookEventCreate :: Int -> Int ->  IO (AuiNotebookEvent  ())
auiNotebookEventCreate commandtype winid 
  = withObjectResult $
    wxAuiNotebookEvent_Create (toCInt commandtype)  (toCInt winid)  
foreign import ccall "wxAuiNotebookEvent_Create" wxAuiNotebookEvent_Create :: CInt -> CInt -> IO (Ptr (TAuiNotebookEvent ()))

-- | usage: (@auiNotebookEventGetDragSource obj@).
auiNotebookEventGetDragSource :: AuiNotebookEvent  a ->  IO (AuiNotebook  ())
auiNotebookEventGetDragSource _obj 
  = withObjectResult $
    withObjectRef "auiNotebookEventGetDragSource" _obj $ \cobj__obj -> 
    wxAuiNotebookEvent_GetDragSource cobj__obj  
foreign import ccall "wxAuiNotebookEvent_GetDragSource" wxAuiNotebookEvent_GetDragSource :: Ptr (TAuiNotebookEvent a) -> IO (Ptr (TAuiNotebook ()))

-- | usage: (@auiNotebookGetArtProvider obj@).
auiNotebookGetArtProvider :: AuiNotebook  a ->  IO (AuiTabArt  ())
auiNotebookGetArtProvider _obj 
  = withObjectResult $
    withObjectRef "auiNotebookGetArtProvider" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetArtProvider cobj__obj  
foreign import ccall "wxAuiNotebook_GetArtProvider" wxAuiNotebook_GetArtProvider :: Ptr (TAuiNotebook a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiNotebookGetCurrentPage obj@).
auiNotebookGetCurrentPage :: AuiNotebook  a ->  IO (Window  ())
auiNotebookGetCurrentPage _obj 
  = withObjectResult $
    withObjectRef "auiNotebookGetCurrentPage" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetCurrentPage cobj__obj  
foreign import ccall "wxAuiNotebook_GetCurrentPage" wxAuiNotebook_GetCurrentPage :: Ptr (TAuiNotebook a) -> IO (Ptr (TWindow ()))

-- | usage: (@auiNotebookGetHeightForPageHeight obj pageHeight@).
auiNotebookGetHeightForPageHeight :: AuiNotebook  a -> Int ->  IO Int
auiNotebookGetHeightForPageHeight _obj pageHeight 
  = withIntResult $
    withObjectRef "auiNotebookGetHeightForPageHeight" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetHeightForPageHeight cobj__obj  (toCInt pageHeight)  
foreign import ccall "wxAuiNotebook_GetHeightForPageHeight" wxAuiNotebook_GetHeightForPageHeight :: Ptr (TAuiNotebook a) -> CInt -> IO CInt

-- | usage: (@auiNotebookGetPage obj pageidx@).
auiNotebookGetPage :: AuiNotebook  a -> Int ->  IO (Window  ())
auiNotebookGetPage _obj pageidx 
  = withObjectResult $
    withObjectRef "auiNotebookGetPage" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetPage cobj__obj  (toCInt pageidx)  
foreign import ccall "wxAuiNotebook_GetPage" wxAuiNotebook_GetPage :: Ptr (TAuiNotebook a) -> CInt -> IO (Ptr (TWindow ()))

-- | usage: (@auiNotebookGetPageBitmap obj page@).
auiNotebookGetPageBitmap :: AuiNotebook  a -> Int ->  IO (Bitmap  ())
auiNotebookGetPageBitmap _obj page 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiNotebookGetPageBitmap" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetPageBitmap cobj__obj  (toCInt page)   pref
foreign import ccall "wxAuiNotebook_GetPageBitmap" wxAuiNotebook_GetPageBitmap :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiNotebookGetPageCount obj@).
auiNotebookGetPageCount :: AuiNotebook  a ->  IO Int
auiNotebookGetPageCount _obj 
  = withIntResult $
    withObjectRef "auiNotebookGetPageCount" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetPageCount cobj__obj  
foreign import ccall "wxAuiNotebook_GetPageCount" wxAuiNotebook_GetPageCount :: Ptr (TAuiNotebook a) -> IO CInt

-- | usage: (@auiNotebookGetPageIndex obj pagewnd@).
auiNotebookGetPageIndex :: AuiNotebook  a -> Window  b ->  IO Int
auiNotebookGetPageIndex _obj _pagewnd 
  = withIntResult $
    withObjectRef "auiNotebookGetPageIndex" _obj $ \cobj__obj -> 
    withObjectPtr _pagewnd $ \cobj__pagewnd -> 
    wxAuiNotebook_GetPageIndex cobj__obj  cobj__pagewnd  
foreign import ccall "wxAuiNotebook_GetPageIndex" wxAuiNotebook_GetPageIndex :: Ptr (TAuiNotebook a) -> Ptr (TWindow b) -> IO CInt

-- | usage: (@auiNotebookGetPageText obj page@).
auiNotebookGetPageText :: AuiNotebook  a -> Int ->  IO (String)
auiNotebookGetPageText _obj page 
  = withManagedStringResult $
    withObjectRef "auiNotebookGetPageText" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetPageText cobj__obj  (toCInt page)  
foreign import ccall "wxAuiNotebook_GetPageText" wxAuiNotebook_GetPageText :: Ptr (TAuiNotebook a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@auiNotebookGetPageToolTip obj pageIdx@).
auiNotebookGetPageToolTip :: AuiNotebook  a -> Int ->  IO (String)
auiNotebookGetPageToolTip _obj pageIdx 
  = withManagedStringResult $
    withObjectRef "auiNotebookGetPageToolTip" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetPageToolTip cobj__obj  (toCInt pageIdx)  
foreign import ccall "wxAuiNotebook_GetPageToolTip" wxAuiNotebook_GetPageToolTip :: Ptr (TAuiNotebook a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@auiNotebookGetSelection obj@).
auiNotebookGetSelection :: AuiNotebook  a ->  IO Int
auiNotebookGetSelection _obj 
  = withIntResult $
    withObjectRef "auiNotebookGetSelection" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetSelection cobj__obj  
foreign import ccall "wxAuiNotebook_GetSelection" wxAuiNotebook_GetSelection :: Ptr (TAuiNotebook a) -> IO CInt

-- | usage: (@auiNotebookGetTabCtrlHeight obj@).
auiNotebookGetTabCtrlHeight :: AuiNotebook  a ->  IO Int
auiNotebookGetTabCtrlHeight _obj 
  = withIntResult $
    withObjectRef "auiNotebookGetTabCtrlHeight" _obj $ \cobj__obj -> 
    wxAuiNotebook_GetTabCtrlHeight cobj__obj  
foreign import ccall "wxAuiNotebook_GetTabCtrlHeight" wxAuiNotebook_GetTabCtrlHeight :: Ptr (TAuiNotebook a) -> IO CInt

-- | usage: (@auiNotebookInsertPage obj index page text select imageId@).
auiNotebookInsertPage :: AuiNotebook  a -> Int -> Window  c -> String -> Bool -> Int ->  IO Bool
auiNotebookInsertPage _obj index _page _text select imageId 
  = withBoolResult $
    withObjectRef "auiNotebookInsertPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _text $ \cobj__text -> 
    wxAuiNotebook_InsertPage cobj__obj  (toCInt index)  cobj__page  cobj__text  (toCBool select)  (toCInt imageId)  
foreign import ccall "wxAuiNotebook_InsertPage" wxAuiNotebook_InsertPage :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TWindow c) -> Ptr (TWxString d) -> CBool -> CInt -> IO CBool

-- | usage: (@auiNotebookInsertPageWithBitmap obj pageidx page caption select bitmap@).
auiNotebookInsertPageWithBitmap :: AuiNotebook  a -> Int -> Window  c -> String -> Bool -> Bitmap  f ->  IO Bool
auiNotebookInsertPageWithBitmap _obj pageidx _page _caption select _bitmap 
  = withBoolResult $
    withObjectRef "auiNotebookInsertPageWithBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _caption $ \cobj__caption -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiNotebook_InsertPageWithBitmap cobj__obj  (toCInt pageidx)  cobj__page  cobj__caption  (toCBool select)  cobj__bitmap  
foreign import ccall "wxAuiNotebook_InsertPageWithBitmap" wxAuiNotebook_InsertPageWithBitmap :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TWindow c) -> Ptr (TWxString d) -> CBool -> Ptr (TBitmap f) -> IO CBool

-- | usage: (@auiNotebookPageActive obj@).
auiNotebookPageActive :: AuiNotebookPage  a ->  IO Bool
auiNotebookPageActive _obj 
  = withBoolResult $
    withObjectRef "auiNotebookPageActive" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Active cobj__obj  
foreign import ccall "wxAuiNotebookPage_Active" wxAuiNotebookPage_Active :: Ptr (TAuiNotebookPage a) -> IO CBool

-- | usage: (@auiNotebookPageArrayCreate@).
auiNotebookPageArrayCreate ::  IO (AuiNotebookPageArray  ())
auiNotebookPageArrayCreate 
  = withObjectResult $
    wxAuiNotebookPageArray_Create 
foreign import ccall "wxAuiNotebookPageArray_Create" wxAuiNotebookPageArray_Create :: IO (Ptr (TAuiNotebookPageArray ()))

-- | usage: (@auiNotebookPageArrayDelete obj@).
auiNotebookPageArrayDelete :: AuiNotebookPageArray  a ->  IO ()
auiNotebookPageArrayDelete _obj 
  = withObjectRef "auiNotebookPageArrayDelete" _obj $ \cobj__obj -> 
    wxAuiNotebookPageArray_Delete cobj__obj  
foreign import ccall "wxAuiNotebookPageArray_Delete" wxAuiNotebookPageArray_Delete :: Ptr (TAuiNotebookPageArray a) -> IO ()

-- | usage: (@auiNotebookPageArrayGetCount obj@).
auiNotebookPageArrayGetCount :: AuiNotebookPageArray  a ->  IO Int
auiNotebookPageArrayGetCount _obj 
  = withIntResult $
    withObjectRef "auiNotebookPageArrayGetCount" _obj $ \cobj__obj -> 
    wxAuiNotebookPageArray_GetCount cobj__obj  
foreign import ccall "wxAuiNotebookPageArray_GetCount" wxAuiNotebookPageArray_GetCount :: Ptr (TAuiNotebookPageArray a) -> IO CInt

-- | usage: (@auiNotebookPageArrayItem obj idx@).
auiNotebookPageArrayItem :: AuiNotebookPageArray  a -> Int ->  IO (AuiNotebookPage  ())
auiNotebookPageArrayItem _obj _idx 
  = withObjectResult $
    withObjectRef "auiNotebookPageArrayItem" _obj $ \cobj__obj -> 
    wxAuiNotebookPageArray_Item cobj__obj  (toCInt _idx)  
foreign import ccall "wxAuiNotebookPageArray_Item" wxAuiNotebookPageArray_Item :: Ptr (TAuiNotebookPageArray a) -> CInt -> IO (Ptr (TAuiNotebookPage ()))

-- | usage: (@auiNotebookPageBitmap obj@).
auiNotebookPageBitmap :: AuiNotebookPage  a ->  IO (Bitmap  ())
auiNotebookPageBitmap _obj 
  = withManagedBitmapResult $
    withObjectRef "auiNotebookPageBitmap" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Bitmap cobj__obj  
foreign import ccall "wxAuiNotebookPage_Bitmap" wxAuiNotebookPage_Bitmap :: Ptr (TAuiNotebookPage a) -> IO (Ptr (TBitmap ()))

-- | usage: (@auiNotebookPageCaption obj@).
auiNotebookPageCaption :: AuiNotebookPage  a ->  IO (String)
auiNotebookPageCaption _obj 
  = withManagedStringResult $
    withObjectRef "auiNotebookPageCaption" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Caption cobj__obj  
foreign import ccall "wxAuiNotebookPage_Caption" wxAuiNotebookPage_Caption :: Ptr (TAuiNotebookPage a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiNotebookPageRect obj@).
auiNotebookPageRect :: AuiNotebookPage  a ->  IO (Rect)
auiNotebookPageRect _obj 
  = withWxRectResult $
    withObjectRef "auiNotebookPageRect" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Rect cobj__obj  
foreign import ccall "wxAuiNotebookPage_Rect" wxAuiNotebookPage_Rect :: Ptr (TAuiNotebookPage a) -> IO (Ptr (TWxRect ()))

-- | usage: (@auiNotebookPageTooltip obj@).
auiNotebookPageTooltip :: AuiNotebookPage  a ->  IO (String)
auiNotebookPageTooltip _obj 
  = withManagedStringResult $
    withObjectRef "auiNotebookPageTooltip" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Tooltip cobj__obj  
foreign import ccall "wxAuiNotebookPage_Tooltip" wxAuiNotebookPage_Tooltip :: Ptr (TAuiNotebookPage a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiNotebookPageWindow obj@).
auiNotebookPageWindow :: AuiNotebookPage  a ->  IO (Window  ())
auiNotebookPageWindow _obj 
  = withObjectResult $
    withObjectRef "auiNotebookPageWindow" _obj $ \cobj__obj -> 
    wxAuiNotebookPage_Window cobj__obj  
foreign import ccall "wxAuiNotebookPage_Window" wxAuiNotebookPage_Window :: Ptr (TAuiNotebookPage a) -> IO (Ptr (TWindow ()))

-- | usage: (@auiNotebookRemovePage obj page@).
auiNotebookRemovePage :: AuiNotebook  a -> Int ->  IO Bool
auiNotebookRemovePage _obj page 
  = withBoolResult $
    withObjectRef "auiNotebookRemovePage" _obj $ \cobj__obj -> 
    wxAuiNotebook_RemovePage cobj__obj  (toCInt page)  
foreign import ccall "wxAuiNotebook_RemovePage" wxAuiNotebook_RemovePage :: Ptr (TAuiNotebook a) -> CInt -> IO CBool

-- | usage: (@auiNotebookSetArtProvider obj art@).
auiNotebookSetArtProvider :: AuiNotebook  a -> AuiTabArt  b ->  IO ()
auiNotebookSetArtProvider _obj _art 
  = withObjectRef "auiNotebookSetArtProvider" _obj $ \cobj__obj -> 
    withObjectPtr _art $ \cobj__art -> 
    wxAuiNotebook_SetArtProvider cobj__obj  cobj__art  
foreign import ccall "wxAuiNotebook_SetArtProvider" wxAuiNotebook_SetArtProvider :: Ptr (TAuiNotebook a) -> Ptr (TAuiTabArt b) -> IO ()

-- | usage: (@auiNotebookSetFont obj font@).
auiNotebookSetFont :: AuiNotebook  a -> Font  b ->  IO Bool
auiNotebookSetFont _obj _font 
  = withBoolResult $
    withObjectRef "auiNotebookSetFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiNotebook_SetFont cobj__obj  cobj__font  
foreign import ccall "wxAuiNotebook_SetFont" wxAuiNotebook_SetFont :: Ptr (TAuiNotebook a) -> Ptr (TFont b) -> IO CBool

-- | usage: (@auiNotebookSetMeasuringFont obj font@).
auiNotebookSetMeasuringFont :: AuiNotebook  a -> Font  b ->  IO ()
auiNotebookSetMeasuringFont _obj _font 
  = withObjectRef "auiNotebookSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiNotebook_SetMeasuringFont cobj__obj  cobj__font  
foreign import ccall "wxAuiNotebook_SetMeasuringFont" wxAuiNotebook_SetMeasuringFont :: Ptr (TAuiNotebook a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiNotebookSetNormalFont obj font@).
auiNotebookSetNormalFont :: AuiNotebook  a -> Font  b ->  IO ()
auiNotebookSetNormalFont _obj _font 
  = withObjectRef "auiNotebookSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiNotebook_SetNormalFont cobj__obj  cobj__font  
foreign import ccall "wxAuiNotebook_SetNormalFont" wxAuiNotebook_SetNormalFont :: Ptr (TAuiNotebook a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiNotebookSetPageBitmap obj page bitmap@).
auiNotebookSetPageBitmap :: AuiNotebook  a -> Int -> Bitmap  c ->  IO Bool
auiNotebookSetPageBitmap _obj page _bitmap 
  = withBoolResult $
    withObjectRef "auiNotebookSetPageBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiNotebook_SetPageBitmap cobj__obj  (toCInt page)  cobj__bitmap  
foreign import ccall "wxAuiNotebook_SetPageBitmap" wxAuiNotebook_SetPageBitmap :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TBitmap c) -> IO CBool

-- | usage: (@auiNotebookSetPageImage obj n imageId@).
auiNotebookSetPageImage :: AuiNotebook  a -> Int -> Int ->  IO Bool
auiNotebookSetPageImage _obj n imageId 
  = withBoolResult $
    withObjectRef "auiNotebookSetPageImage" _obj $ \cobj__obj -> 
    wxAuiNotebook_SetPageImage cobj__obj  (toCInt n)  (toCInt imageId)  
foreign import ccall "wxAuiNotebook_SetPageImage" wxAuiNotebook_SetPageImage :: Ptr (TAuiNotebook a) -> CInt -> CInt -> IO CBool

-- | usage: (@auiNotebookSetPageText obj page text@).
auiNotebookSetPageText :: AuiNotebook  a -> Int -> String ->  IO Bool
auiNotebookSetPageText _obj page _text 
  = withBoolResult $
    withObjectRef "auiNotebookSetPageText" _obj $ \cobj__obj -> 
    withStringPtr _text $ \cobj__text -> 
    wxAuiNotebook_SetPageText cobj__obj  (toCInt page)  cobj__text  
foreign import ccall "wxAuiNotebook_SetPageText" wxAuiNotebook_SetPageText :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TWxString c) -> IO CBool

-- | usage: (@auiNotebookSetPageToolTip obj page text@).
auiNotebookSetPageToolTip :: AuiNotebook  a -> Int -> String ->  IO Bool
auiNotebookSetPageToolTip _obj page _text 
  = withBoolResult $
    withObjectRef "auiNotebookSetPageToolTip" _obj $ \cobj__obj -> 
    withStringPtr _text $ \cobj__text -> 
    wxAuiNotebook_SetPageToolTip cobj__obj  (toCInt page)  cobj__text  
foreign import ccall "wxAuiNotebook_SetPageToolTip" wxAuiNotebook_SetPageToolTip :: Ptr (TAuiNotebook a) -> CInt -> Ptr (TWxString c) -> IO CBool

-- | usage: (@auiNotebookSetSelectedFont obj font@).
auiNotebookSetSelectedFont :: AuiNotebook  a -> Font  b ->  IO ()
auiNotebookSetSelectedFont _obj _font 
  = withObjectRef "auiNotebookSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiNotebook_SetSelectedFont cobj__obj  cobj__font  
foreign import ccall "wxAuiNotebook_SetSelectedFont" wxAuiNotebook_SetSelectedFont :: Ptr (TAuiNotebook a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiNotebookSetSelection obj newpage@).
auiNotebookSetSelection :: AuiNotebook  a -> Int ->  IO Int
auiNotebookSetSelection _obj newpage 
  = withIntResult $
    withObjectRef "auiNotebookSetSelection" _obj $ \cobj__obj -> 
    wxAuiNotebook_SetSelection cobj__obj  (toCInt newpage)  
foreign import ccall "wxAuiNotebook_SetSelection" wxAuiNotebook_SetSelection :: Ptr (TAuiNotebook a) -> CInt -> IO CInt

-- | usage: (@auiNotebookSetTabCtrlHeight obj height@).
auiNotebookSetTabCtrlHeight :: AuiNotebook  a -> Int ->  IO ()
auiNotebookSetTabCtrlHeight _obj height 
  = withObjectRef "auiNotebookSetTabCtrlHeight" _obj $ \cobj__obj -> 
    wxAuiNotebook_SetTabCtrlHeight cobj__obj  (toCInt height)  
foreign import ccall "wxAuiNotebook_SetTabCtrlHeight" wxAuiNotebook_SetTabCtrlHeight :: Ptr (TAuiNotebook a) -> CInt -> IO ()

-- | usage: (@auiNotebookSetUniformBitmapSize obj widthheight@).
auiNotebookSetUniformBitmapSize :: AuiNotebook  a -> Size ->  IO ()
auiNotebookSetUniformBitmapSize _obj _widthheight 
  = withObjectRef "auiNotebookSetUniformBitmapSize" _obj $ \cobj__obj -> 
    wxAuiNotebook_SetUniformBitmapSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiNotebook_SetUniformBitmapSize" wxAuiNotebook_SetUniformBitmapSize :: Ptr (TAuiNotebook a) -> CInt -> CInt -> IO ()

-- | usage: (@auiNotebookShowWindowMenu obj@).
auiNotebookShowWindowMenu :: AuiNotebook  a ->  IO Bool
auiNotebookShowWindowMenu _obj 
  = withBoolResult $
    withObjectRef "auiNotebookShowWindowMenu" _obj $ \cobj__obj -> 
    wxAuiNotebook_ShowWindowMenu cobj__obj  
foreign import ccall "wxAuiNotebook_ShowWindowMenu" wxAuiNotebook_ShowWindowMenu :: Ptr (TAuiNotebook a) -> IO CBool

-- | usage: (@auiNotebookSplit obj page direction@).
auiNotebookSplit :: AuiNotebook  a -> Int -> Int ->  IO ()
auiNotebookSplit _obj page direction 
  = withObjectRef "auiNotebookSplit" _obj $ \cobj__obj -> 
    wxAuiNotebook_Split cobj__obj  (toCInt page)  (toCInt direction)  
foreign import ccall "wxAuiNotebook_Split" wxAuiNotebook_Split :: Ptr (TAuiNotebook a) -> CInt -> CInt -> IO ()

-- | usage: (@auiPaneInfoArrayCreate@).
auiPaneInfoArrayCreate ::  IO (AuiPaneInfoArray  ())
auiPaneInfoArrayCreate 
  = withObjectResult $
    wxAuiPaneInfoArray_Create 
foreign import ccall "wxAuiPaneInfoArray_Create" wxAuiPaneInfoArray_Create :: IO (Ptr (TAuiPaneInfoArray ()))

-- | usage: (@auiPaneInfoArrayDelete obj@).
auiPaneInfoArrayDelete :: AuiPaneInfoArray  a ->  IO ()
auiPaneInfoArrayDelete _obj 
  = withObjectRef "auiPaneInfoArrayDelete" _obj $ \cobj__obj -> 
    wxAuiPaneInfoArray_Delete cobj__obj  
foreign import ccall "wxAuiPaneInfoArray_Delete" wxAuiPaneInfoArray_Delete :: Ptr (TAuiPaneInfoArray a) -> IO ()

-- | usage: (@auiPaneInfoArrayGetCount obj@).
auiPaneInfoArrayGetCount :: AuiPaneInfoArray  a ->  IO Int
auiPaneInfoArrayGetCount _obj 
  = withIntResult $
    withObjectRef "auiPaneInfoArrayGetCount" _obj $ \cobj__obj -> 
    wxAuiPaneInfoArray_GetCount cobj__obj  
foreign import ccall "wxAuiPaneInfoArray_GetCount" wxAuiPaneInfoArray_GetCount :: Ptr (TAuiPaneInfoArray a) -> IO CInt

-- | usage: (@auiPaneInfoArrayItem obj idx@).
auiPaneInfoArrayItem :: AuiPaneInfoArray  a -> Int ->  IO (AuiPaneInfo  ())
auiPaneInfoArrayItem _obj _idx 
  = withObjectResult $
    withObjectRef "auiPaneInfoArrayItem" _obj $ \cobj__obj -> 
    wxAuiPaneInfoArray_Item cobj__obj  (toCInt _idx)  
foreign import ccall "wxAuiPaneInfoArray_Item" wxAuiPaneInfoArray_Item :: Ptr (TAuiPaneInfoArray a) -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoBestSize obj widthheight@).
auiPaneInfoBestSize :: AuiPaneInfo  a -> Size ->  IO (AuiPaneInfo  ())
auiPaneInfoBestSize _obj _widthheight 
  = withObjectResult $
    withObjectRef "auiPaneInfoBestSize" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_BestSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiPaneInfo_BestSize" wxAuiPaneInfo_BestSize :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoBestSizeXY obj xy@).
auiPaneInfoBestSizeXY :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoBestSizeXY _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoBestSizeXY" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_BestSizeXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_BestSizeXY" wxAuiPaneInfo_BestSizeXY :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoBottom obj@).
auiPaneInfoBottom :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoBottom _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoBottom" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Bottom cobj__obj  
foreign import ccall "wxAuiPaneInfo_Bottom" wxAuiPaneInfo_Bottom :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoBottomDockable obj b@).
auiPaneInfoBottomDockable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoBottomDockable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoBottomDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_BottomDockable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_BottomDockable" wxAuiPaneInfo_BottomDockable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCaption obj c@).
auiPaneInfoCaption :: AuiPaneInfo  a -> String ->  IO (AuiPaneInfo  ())
auiPaneInfoCaption _obj _c 
  = withObjectResult $
    withObjectRef "auiPaneInfoCaption" _obj $ \cobj__obj -> 
    withStringPtr _c $ \cobj__c -> 
    wxAuiPaneInfo_Caption cobj__obj  cobj__c  
foreign import ccall "wxAuiPaneInfo_Caption" wxAuiPaneInfo_Caption :: Ptr (TAuiPaneInfo a) -> Ptr (TWxString b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCaptionVisible obj visible@).
auiPaneInfoCaptionVisible :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoCaptionVisible _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoCaptionVisible" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_CaptionVisible cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_CaptionVisible" wxAuiPaneInfo_CaptionVisible :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCenter obj@).
auiPaneInfoCenter :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoCenter _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoCenter" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Center cobj__obj  
foreign import ccall "wxAuiPaneInfo_Center" wxAuiPaneInfo_Center :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCenterPane obj@).
auiPaneInfoCenterPane :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoCenterPane _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoCenterPane" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_CenterPane cobj__obj  
foreign import ccall "wxAuiPaneInfo_CenterPane" wxAuiPaneInfo_CenterPane :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCentre obj@).
auiPaneInfoCentre :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoCentre _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoCentre" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Centre cobj__obj  
foreign import ccall "wxAuiPaneInfo_Centre" wxAuiPaneInfo_Centre :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCentrePane obj@).
auiPaneInfoCentrePane :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoCentrePane _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoCentrePane" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_CentrePane cobj__obj  
foreign import ccall "wxAuiPaneInfo_CentrePane" wxAuiPaneInfo_CentrePane :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCloseButton obj visible@).
auiPaneInfoCloseButton :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoCloseButton _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoCloseButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_CloseButton cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_CloseButton" wxAuiPaneInfo_CloseButton :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCopy obj c@).
auiPaneInfoCopy :: AuiPaneInfo  a -> AuiPaneInfo  b ->  IO (AuiPaneInfo  ())
auiPaneInfoCopy _obj _c 
  = withObjectResult $
    withObjectRef "auiPaneInfoCopy" _obj $ \cobj__obj -> 
    withObjectPtr _c $ \cobj__c -> 
    wxAuiPaneInfo_Copy cobj__obj  cobj__c  
foreign import ccall "wxAuiPaneInfo_Copy" wxAuiPaneInfo_Copy :: Ptr (TAuiPaneInfo a) -> Ptr (TAuiPaneInfo b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCreate c@).
auiPaneInfoCreate :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoCreate _c 
  = withObjectResult $
    withObjectPtr _c $ \cobj__c -> 
    wxAuiPaneInfo_Create cobj__c  
foreign import ccall "wxAuiPaneInfo_Create" wxAuiPaneInfo_Create :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoCreateDefault@).
auiPaneInfoCreateDefault ::  IO (AuiPaneInfo  ())
auiPaneInfoCreateDefault 
  = withObjectResult $
    wxAuiPaneInfo_CreateDefault 
foreign import ccall "wxAuiPaneInfo_CreateDefault" wxAuiPaneInfo_CreateDefault :: IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDefaultPane obj@).
auiPaneInfoDefaultPane :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoDefaultPane _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoDefaultPane" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_DefaultPane cobj__obj  
foreign import ccall "wxAuiPaneInfo_DefaultPane" wxAuiPaneInfo_DefaultPane :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDestroyOnClose obj b@).
auiPaneInfoDestroyOnClose :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoDestroyOnClose _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoDestroyOnClose" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_DestroyOnClose cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_DestroyOnClose" wxAuiPaneInfo_DestroyOnClose :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDirection obj direction@).
auiPaneInfoDirection :: AuiPaneInfo  a -> Int ->  IO (AuiPaneInfo  ())
auiPaneInfoDirection _obj direction 
  = withObjectResult $
    withObjectRef "auiPaneInfoDirection" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Direction cobj__obj  (toCInt direction)  
foreign import ccall "wxAuiPaneInfo_Direction" wxAuiPaneInfo_Direction :: Ptr (TAuiPaneInfo a) -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDock obj@).
auiPaneInfoDock :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoDock _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoDock" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Dock cobj__obj  
foreign import ccall "wxAuiPaneInfo_Dock" wxAuiPaneInfo_Dock :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDockFixed obj b@).
auiPaneInfoDockFixed :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoDockFixed _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoDockFixed" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_DockFixed cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_DockFixed" wxAuiPaneInfo_DockFixed :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoDockable obj b@).
auiPaneInfoDockable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoDockable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Dockable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_Dockable" wxAuiPaneInfo_Dockable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFixed obj@).
auiPaneInfoFixed :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoFixed _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoFixed" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Fixed cobj__obj  
foreign import ccall "wxAuiPaneInfo_Fixed" wxAuiPaneInfo_Fixed :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloat obj@).
auiPaneInfoFloat :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoFloat _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloat" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Float cobj__obj  
foreign import ccall "wxAuiPaneInfo_Float" wxAuiPaneInfo_Float :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloatable obj b@).
auiPaneInfoFloatable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoFloatable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloatable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Floatable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_Floatable" wxAuiPaneInfo_Floatable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloatingPosition obj xy@).
auiPaneInfoFloatingPosition :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoFloatingPosition _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloatingPosition" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_FloatingPosition cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_FloatingPosition" wxAuiPaneInfo_FloatingPosition :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloatingPositionXY obj xy@).
auiPaneInfoFloatingPositionXY :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoFloatingPositionXY _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloatingPositionXY" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_FloatingPositionXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_FloatingPositionXY" wxAuiPaneInfo_FloatingPositionXY :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloatingSize obj widthheight@).
auiPaneInfoFloatingSize :: AuiPaneInfo  a -> Size ->  IO (AuiPaneInfo  ())
auiPaneInfoFloatingSize _obj _widthheight 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloatingSize" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_FloatingSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiPaneInfo_FloatingSize" wxAuiPaneInfo_FloatingSize :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoFloatingSizeXY obj xy@).
auiPaneInfoFloatingSizeXY :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoFloatingSizeXY _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoFloatingSizeXY" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_FloatingSizeXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_FloatingSizeXY" wxAuiPaneInfo_FloatingSizeXY :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoGripper obj visible@).
auiPaneInfoGripper :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoGripper _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoGripper" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Gripper cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_Gripper" wxAuiPaneInfo_Gripper :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoGripperTop obj attop@).
auiPaneInfoGripperTop :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoGripperTop _obj attop 
  = withObjectResult $
    withObjectRef "auiPaneInfoGripperTop" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_GripperTop cobj__obj  (toCBool attop)  
foreign import ccall "wxAuiPaneInfo_GripperTop" wxAuiPaneInfo_GripperTop :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoHasBorder obj@).
auiPaneInfoHasBorder :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasBorder _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasBorder" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasBorder cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasBorder" wxAuiPaneInfo_HasBorder :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasCaption obj@).
auiPaneInfoHasCaption :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasCaption _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasCaption" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasCaption cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasCaption" wxAuiPaneInfo_HasCaption :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasCloseButton obj@).
auiPaneInfoHasCloseButton :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasCloseButton _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasCloseButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasCloseButton cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasCloseButton" wxAuiPaneInfo_HasCloseButton :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasFlag obj flag@).
auiPaneInfoHasFlag :: AuiPaneInfo  a -> Int ->  IO Bool
auiPaneInfoHasFlag _obj flag 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasFlag" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasFlag cobj__obj  (toCInt flag)  
foreign import ccall "wxAuiPaneInfo_HasFlag" wxAuiPaneInfo_HasFlag :: Ptr (TAuiPaneInfo a) -> CInt -> IO CBool

-- | usage: (@auiPaneInfoHasGripper obj@).
auiPaneInfoHasGripper :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasGripper _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasGripper" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasGripper cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasGripper" wxAuiPaneInfo_HasGripper :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasGripperTop obj@).
auiPaneInfoHasGripperTop :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasGripperTop _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasGripperTop" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasGripperTop cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasGripperTop" wxAuiPaneInfo_HasGripperTop :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasMaximizeButton obj@).
auiPaneInfoHasMaximizeButton :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasMaximizeButton _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasMaximizeButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasMaximizeButton cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasMaximizeButton" wxAuiPaneInfo_HasMaximizeButton :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasMinimizeButton obj@).
auiPaneInfoHasMinimizeButton :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasMinimizeButton _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasMinimizeButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasMinimizeButton cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasMinimizeButton" wxAuiPaneInfo_HasMinimizeButton :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHasPinButton obj@).
auiPaneInfoHasPinButton :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoHasPinButton _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoHasPinButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_HasPinButton cobj__obj  
foreign import ccall "wxAuiPaneInfo_HasPinButton" wxAuiPaneInfo_HasPinButton :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoHide obj@).
auiPaneInfoHide :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoHide _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoHide" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Hide cobj__obj  
foreign import ccall "wxAuiPaneInfo_Hide" wxAuiPaneInfo_Hide :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoIcon obj b@).
auiPaneInfoIcon :: AuiPaneInfo  a -> Bitmap  b ->  IO (AuiPaneInfo  ())
auiPaneInfoIcon _obj _b 
  = withObjectResult $
    withObjectRef "auiPaneInfoIcon" _obj $ \cobj__obj -> 
    withObjectPtr _b $ \cobj__b -> 
    wxAuiPaneInfo_Icon cobj__obj  cobj__b  
foreign import ccall "wxAuiPaneInfo_Icon" wxAuiPaneInfo_Icon :: Ptr (TAuiPaneInfo a) -> Ptr (TBitmap b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoIsBottomDockable obj@).
auiPaneInfoIsBottomDockable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsBottomDockable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsBottomDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsBottomDockable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsBottomDockable" wxAuiPaneInfo_IsBottomDockable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsDockable obj@).
auiPaneInfoIsDockable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsDockable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsDockable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsDockable" wxAuiPaneInfo_IsDockable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsDocked obj@).
auiPaneInfoIsDocked :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsDocked _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsDocked" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsDocked cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsDocked" wxAuiPaneInfo_IsDocked :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsFixed obj@).
auiPaneInfoIsFixed :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsFixed _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsFixed" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsFixed cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsFixed" wxAuiPaneInfo_IsFixed :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsFloatable obj@).
auiPaneInfoIsFloatable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsFloatable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsFloatable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsFloatable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsFloatable" wxAuiPaneInfo_IsFloatable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsFloating obj@).
auiPaneInfoIsFloating :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsFloating _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsFloating" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsFloating cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsFloating" wxAuiPaneInfo_IsFloating :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsLeftDockable obj@).
auiPaneInfoIsLeftDockable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsLeftDockable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsLeftDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsLeftDockable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsLeftDockable" wxAuiPaneInfo_IsLeftDockable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsMovable obj@).
auiPaneInfoIsMovable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsMovable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsMovable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsMovable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsMovable" wxAuiPaneInfo_IsMovable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsOk obj@).
auiPaneInfoIsOk :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsOk _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsOk" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsOk cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsOk" wxAuiPaneInfo_IsOk :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsResizable obj@).
auiPaneInfoIsResizable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsResizable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsResizable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsResizable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsResizable" wxAuiPaneInfo_IsResizable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsRightDockable obj@).
auiPaneInfoIsRightDockable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsRightDockable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsRightDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsRightDockable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsRightDockable" wxAuiPaneInfo_IsRightDockable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsShown obj@).
auiPaneInfoIsShown :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsShown _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsShown" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsShown cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsShown" wxAuiPaneInfo_IsShown :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsToolbar obj@).
auiPaneInfoIsToolbar :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsToolbar _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsToolbar" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsToolbar cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsToolbar" wxAuiPaneInfo_IsToolbar :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoIsTopDockable obj@).
auiPaneInfoIsTopDockable :: AuiPaneInfo  a ->  IO Bool
auiPaneInfoIsTopDockable _obj 
  = withBoolResult $
    withObjectRef "auiPaneInfoIsTopDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_IsTopDockable cobj__obj  
foreign import ccall "wxAuiPaneInfo_IsTopDockable" wxAuiPaneInfo_IsTopDockable :: Ptr (TAuiPaneInfo a) -> IO CBool

-- | usage: (@auiPaneInfoLayer obj layer@).
auiPaneInfoLayer :: AuiPaneInfo  a -> Int ->  IO (AuiPaneInfo  ())
auiPaneInfoLayer _obj layer 
  = withObjectResult $
    withObjectRef "auiPaneInfoLayer" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Layer cobj__obj  (toCInt layer)  
foreign import ccall "wxAuiPaneInfo_Layer" wxAuiPaneInfo_Layer :: Ptr (TAuiPaneInfo a) -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoLeft obj@).
auiPaneInfoLeft :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoLeft _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoLeft" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Left cobj__obj  
foreign import ccall "wxAuiPaneInfo_Left" wxAuiPaneInfo_Left :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoLeftDockable obj b@).
auiPaneInfoLeftDockable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoLeftDockable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoLeftDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_LeftDockable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_LeftDockable" wxAuiPaneInfo_LeftDockable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMaxSize obj widthheight@).
auiPaneInfoMaxSize :: AuiPaneInfo  a -> Size ->  IO (AuiPaneInfo  ())
auiPaneInfoMaxSize _obj _widthheight 
  = withObjectResult $
    withObjectRef "auiPaneInfoMaxSize" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MaxSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiPaneInfo_MaxSize" wxAuiPaneInfo_MaxSize :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMaxSizeXY obj xy@).
auiPaneInfoMaxSizeXY :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoMaxSizeXY _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoMaxSizeXY" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MaxSizeXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_MaxSizeXY" wxAuiPaneInfo_MaxSizeXY :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMaximizeButton obj visible@).
auiPaneInfoMaximizeButton :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoMaximizeButton _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoMaximizeButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MaximizeButton cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_MaximizeButton" wxAuiPaneInfo_MaximizeButton :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMinSize obj widthheight@).
auiPaneInfoMinSize :: AuiPaneInfo  a -> Size ->  IO (AuiPaneInfo  ())
auiPaneInfoMinSize _obj _widthheight 
  = withObjectResult $
    withObjectRef "auiPaneInfoMinSize" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MinSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiPaneInfo_MinSize" wxAuiPaneInfo_MinSize :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMinSizeXY obj xy@).
auiPaneInfoMinSizeXY :: AuiPaneInfo  a -> Point ->  IO (AuiPaneInfo  ())
auiPaneInfoMinSizeXY _obj xy 
  = withObjectResult $
    withObjectRef "auiPaneInfoMinSizeXY" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MinSizeXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiPaneInfo_MinSizeXY" wxAuiPaneInfo_MinSizeXY :: Ptr (TAuiPaneInfo a) -> CInt -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMinimizeButton obj visible@).
auiPaneInfoMinimizeButton :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoMinimizeButton _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoMinimizeButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_MinimizeButton cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_MinimizeButton" wxAuiPaneInfo_MinimizeButton :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoMovable obj b@).
auiPaneInfoMovable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoMovable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoMovable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Movable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_Movable" wxAuiPaneInfo_Movable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoName obj n@).
auiPaneInfoName :: AuiPaneInfo  a -> String ->  IO (AuiPaneInfo  ())
auiPaneInfoName _obj _n 
  = withObjectResult $
    withObjectRef "auiPaneInfoName" _obj $ \cobj__obj -> 
    withStringPtr _n $ \cobj__n -> 
    wxAuiPaneInfo_Name cobj__obj  cobj__n  
foreign import ccall "wxAuiPaneInfo_Name" wxAuiPaneInfo_Name :: Ptr (TAuiPaneInfo a) -> Ptr (TWxString b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoPaneBorder obj visible@).
auiPaneInfoPaneBorder :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoPaneBorder _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoPaneBorder" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_PaneBorder cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_PaneBorder" wxAuiPaneInfo_PaneBorder :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoPinButton obj visible@).
auiPaneInfoPinButton :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoPinButton _obj visible 
  = withObjectResult $
    withObjectRef "auiPaneInfoPinButton" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_PinButton cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiPaneInfo_PinButton" wxAuiPaneInfo_PinButton :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoPosition obj pos@).
auiPaneInfoPosition :: AuiPaneInfo  a -> Int ->  IO (AuiPaneInfo  ())
auiPaneInfoPosition _obj pos 
  = withObjectResult $
    withObjectRef "auiPaneInfoPosition" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Position cobj__obj  (toCInt pos)  
foreign import ccall "wxAuiPaneInfo_Position" wxAuiPaneInfo_Position :: Ptr (TAuiPaneInfo a) -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoResizable obj resizable@).
auiPaneInfoResizable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoResizable _obj resizable 
  = withObjectResult $
    withObjectRef "auiPaneInfoResizable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Resizable cobj__obj  (toCBool resizable)  
foreign import ccall "wxAuiPaneInfo_Resizable" wxAuiPaneInfo_Resizable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoRight obj@).
auiPaneInfoRight :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoRight _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoRight" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Right cobj__obj  
foreign import ccall "wxAuiPaneInfo_Right" wxAuiPaneInfo_Right :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoRightDockable obj b@).
auiPaneInfoRightDockable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoRightDockable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoRightDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_RightDockable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_RightDockable" wxAuiPaneInfo_RightDockable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoRow obj row@).
auiPaneInfoRow :: AuiPaneInfo  a -> Int ->  IO (AuiPaneInfo  ())
auiPaneInfoRow _obj row 
  = withObjectResult $
    withObjectRef "auiPaneInfoRow" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Row cobj__obj  (toCInt row)  
foreign import ccall "wxAuiPaneInfo_Row" wxAuiPaneInfo_Row :: Ptr (TAuiPaneInfo a) -> CInt -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoSafeSet obj source@).
auiPaneInfoSafeSet :: AuiPaneInfo  a -> AuiPaneInfo  b ->  IO ()
auiPaneInfoSafeSet _obj source 
  = withObjectRef "auiPaneInfoSafeSet" _obj $ \cobj__obj -> 
    withObjectPtr source $ \cobj_source -> 
    wxAuiPaneInfo_SafeSet cobj__obj  cobj_source  
foreign import ccall "wxAuiPaneInfo_SafeSet" wxAuiPaneInfo_SafeSet :: Ptr (TAuiPaneInfo a) -> Ptr (TAuiPaneInfo b) -> IO ()

-- | usage: (@auiPaneInfoSetFlag obj flag optionstate@).
auiPaneInfoSetFlag :: AuiPaneInfo  a -> Int -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoSetFlag _obj flag optionstate 
  = withObjectResult $
    withObjectRef "auiPaneInfoSetFlag" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_SetFlag cobj__obj  (toCInt flag)  (toCBool optionstate)  
foreign import ccall "wxAuiPaneInfo_SetFlag" wxAuiPaneInfo_SetFlag :: Ptr (TAuiPaneInfo a) -> CInt -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoShow obj show@).
auiPaneInfoShow :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoShow _obj show 
  = withObjectResult $
    withObjectRef "auiPaneInfoShow" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Show cobj__obj  (toCBool show)  
foreign import ccall "wxAuiPaneInfo_Show" wxAuiPaneInfo_Show :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoToolbarPane obj@).
auiPaneInfoToolbarPane :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoToolbarPane _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoToolbarPane" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_ToolbarPane cobj__obj  
foreign import ccall "wxAuiPaneInfo_ToolbarPane" wxAuiPaneInfo_ToolbarPane :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoTop obj@).
auiPaneInfoTop :: AuiPaneInfo  a ->  IO (AuiPaneInfo  ())
auiPaneInfoTop _obj 
  = withObjectResult $
    withObjectRef "auiPaneInfoTop" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_Top cobj__obj  
foreign import ccall "wxAuiPaneInfo_Top" wxAuiPaneInfo_Top :: Ptr (TAuiPaneInfo a) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoTopDockable obj b@).
auiPaneInfoTopDockable :: AuiPaneInfo  a -> Bool ->  IO (AuiPaneInfo  ())
auiPaneInfoTopDockable _obj b 
  = withObjectResult $
    withObjectRef "auiPaneInfoTopDockable" _obj $ \cobj__obj -> 
    wxAuiPaneInfo_TopDockable cobj__obj  (toCBool b)  
foreign import ccall "wxAuiPaneInfo_TopDockable" wxAuiPaneInfo_TopDockable :: Ptr (TAuiPaneInfo a) -> CBool -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiPaneInfoWindow obj w@).
auiPaneInfoWindow :: AuiPaneInfo  a -> Window  b ->  IO (AuiPaneInfo  ())
auiPaneInfoWindow _obj _w 
  = withObjectResult $
    withObjectRef "auiPaneInfoWindow" _obj $ \cobj__obj -> 
    withObjectPtr _w $ \cobj__w -> 
    wxAuiPaneInfo_Window cobj__obj  cobj__w  
foreign import ccall "wxAuiPaneInfo_Window" wxAuiPaneInfo_Window :: Ptr (TAuiPaneInfo a) -> Ptr (TWindow b) -> IO (Ptr (TAuiPaneInfo ()))

-- | usage: (@auiSimpleTabArtClone obj@).
auiSimpleTabArtClone :: AuiSimpleTabArt  a ->  IO (AuiTabArt  ())
auiSimpleTabArtClone _obj 
  = withObjectResult $
    withObjectRef "auiSimpleTabArtClone" _obj $ \cobj__obj -> 
    wxAuiSimpleTabArt_Clone cobj__obj  
foreign import ccall "wxAuiSimpleTabArt_Clone" wxAuiSimpleTabArt_Clone :: Ptr (TAuiSimpleTabArt a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiSimpleTabArtCreate@).
auiSimpleTabArtCreate ::  IO (AuiSimpleTabArt  ())
auiSimpleTabArtCreate 
  = withObjectResult $
    wxAuiSimpleTabArt_Create 
foreign import ccall "wxAuiSimpleTabArt_Create" wxAuiSimpleTabArt_Create :: IO (Ptr (TAuiSimpleTabArt ()))

-- | usage: (@auiSimpleTabArtDrawBackground obj dc wnd rect@).
auiSimpleTabArtDrawBackground :: AuiSimpleTabArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiSimpleTabArtDrawBackground _obj _dc _wnd _rect 
  = withObjectRef "auiSimpleTabArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiSimpleTabArt_DrawBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiSimpleTabArt_DrawBackground" wxAuiSimpleTabArt_DrawBackground :: Ptr (TAuiSimpleTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiSimpleTabArtDrawButton obj dc wnd inRect bitmapId buttonState orientation outRect@).
auiSimpleTabArtDrawButton :: AuiSimpleTabArt  a -> DC  b -> Window  c -> Rect -> Int -> Int -> Int -> Rect ->  IO ()
auiSimpleTabArtDrawButton _obj _dc _wnd _inRect bitmapId buttonState orientation _outRect 
  = withObjectRef "auiSimpleTabArtDrawButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _inRect $ \cobj__inRect -> 
    withWxRectPtr _outRect $ \cobj__outRect -> 
    wxAuiSimpleTabArt_DrawButton cobj__obj  cobj__dc  cobj__wnd  cobj__inRect  (toCInt bitmapId)  (toCInt buttonState)  (toCInt orientation)  cobj__outRect  
foreign import ccall "wxAuiSimpleTabArt_DrawButton" wxAuiSimpleTabArt_DrawButton :: Ptr (TAuiSimpleTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> CInt -> CInt -> CInt -> Ptr (TWxRect h) -> IO ()

-- | usage: (@auiSimpleTabArtDrawTab obj dc wnd pane inRect closeButtonState outTabRect outButtonRect xExtent@).
auiSimpleTabArtDrawTab :: AuiSimpleTabArt  a -> DC  b -> Window  c -> AuiNotebookPage  d -> Rect -> Int -> Rect -> Rect -> Ptr CInt ->  IO ()
auiSimpleTabArtDrawTab _obj _dc _wnd _pane _inRect closeButtonState _outTabRect _outButtonRect xExtent 
  = withObjectRef "auiSimpleTabArtDrawTab" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _pane $ \cobj__pane -> 
    withWxRectPtr _inRect $ \cobj__inRect -> 
    withWxRectPtr _outTabRect $ \cobj__outTabRect -> 
    withWxRectPtr _outButtonRect $ \cobj__outButtonRect -> 
    wxAuiSimpleTabArt_DrawTab cobj__obj  cobj__dc  cobj__wnd  cobj__pane  cobj__inRect  (toCInt closeButtonState)  cobj__outTabRect  cobj__outButtonRect  xExtent  
foreign import ccall "wxAuiSimpleTabArt_DrawTab" wxAuiSimpleTabArt_DrawTab :: Ptr (TAuiSimpleTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiNotebookPage d) -> Ptr (TWxRect e) -> CInt -> Ptr (TWxRect g) -> Ptr (TWxRect h) -> Ptr CInt -> IO ()

-- | usage: (@auiSimpleTabArtGetBestTabCtrlSize obj wnd pages widthheight@).
auiSimpleTabArtGetBestTabCtrlSize :: AuiSimpleTabArt  a -> Window  b -> AuiNotebookPageArray  c -> Size ->  IO Int
auiSimpleTabArtGetBestTabCtrlSize _obj _wnd _pages _widthheight 
  = withIntResult $
    withObjectRef "auiSimpleTabArtGetBestTabCtrlSize" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _pages $ \cobj__pages -> 
    wxAuiSimpleTabArt_GetBestTabCtrlSize cobj__obj  cobj__wnd  cobj__pages  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiSimpleTabArt_GetBestTabCtrlSize" wxAuiSimpleTabArt_GetBestTabCtrlSize :: Ptr (TAuiSimpleTabArt a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPageArray c) -> CInt -> CInt -> IO CInt

-- | usage: (@auiSimpleTabArtGetIndentSize obj@).
auiSimpleTabArtGetIndentSize :: AuiSimpleTabArt  a ->  IO Int
auiSimpleTabArtGetIndentSize _obj 
  = withIntResult $
    withObjectRef "auiSimpleTabArtGetIndentSize" _obj $ \cobj__obj -> 
    wxAuiSimpleTabArt_GetIndentSize cobj__obj  
foreign import ccall "wxAuiSimpleTabArt_GetIndentSize" wxAuiSimpleTabArt_GetIndentSize :: Ptr (TAuiSimpleTabArt a) -> IO CInt

-- | usage: (@auiSimpleTabArtGetTabSize obj dc wnd caption bitmap active closeButtonState xExtent@).
auiSimpleTabArtGetTabSize :: AuiSimpleTabArt  a -> DC  b -> Window  c -> String -> Bitmap  e -> Bool -> Int -> Ptr CInt ->  IO (Size)
auiSimpleTabArtGetTabSize _obj _dc _wnd _caption _bitmap active closeButtonState xExtent 
  = withWxSizeResult $
    withObjectRef "auiSimpleTabArtGetTabSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withStringPtr _caption $ \cobj__caption -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiSimpleTabArt_GetTabSize cobj__obj  cobj__dc  cobj__wnd  cobj__caption  cobj__bitmap  (toCBool active)  (toCInt closeButtonState)  xExtent  
foreign import ccall "wxAuiSimpleTabArt_GetTabSize" wxAuiSimpleTabArt_GetTabSize :: Ptr (TAuiSimpleTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxString d) -> Ptr (TBitmap e) -> CBool -> CInt -> Ptr CInt -> IO (Ptr (TWxSize ()))

-- | usage: (@auiSimpleTabArtSetActiveColour obj colour@).
auiSimpleTabArtSetActiveColour :: AuiSimpleTabArt  a -> Color ->  IO ()
auiSimpleTabArtSetActiveColour _obj _colour 
  = withObjectRef "auiSimpleTabArtSetActiveColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiSimpleTabArt_SetActiveColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiSimpleTabArt_SetActiveColour" wxAuiSimpleTabArt_SetActiveColour :: Ptr (TAuiSimpleTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiSimpleTabArtSetColour obj colour@).
auiSimpleTabArtSetColour :: AuiSimpleTabArt  a -> Color ->  IO ()
auiSimpleTabArtSetColour _obj _colour 
  = withObjectRef "auiSimpleTabArtSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiSimpleTabArt_SetColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiSimpleTabArt_SetColour" wxAuiSimpleTabArt_SetColour :: Ptr (TAuiSimpleTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiSimpleTabArtSetFlags obj flags@).
auiSimpleTabArtSetFlags :: AuiSimpleTabArt  a -> Int ->  IO ()
auiSimpleTabArtSetFlags _obj _flags 
  = withObjectRef "auiSimpleTabArtSetFlags" _obj $ \cobj__obj -> 
    wxAuiSimpleTabArt_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiSimpleTabArt_SetFlags" wxAuiSimpleTabArt_SetFlags :: Ptr (TAuiSimpleTabArt a) -> CInt -> IO ()

-- | usage: (@auiSimpleTabArtSetMeasuringFont obj font@).
auiSimpleTabArtSetMeasuringFont :: AuiSimpleTabArt  a -> Font  b ->  IO ()
auiSimpleTabArtSetMeasuringFont _obj _font 
  = withObjectRef "auiSimpleTabArtSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiSimpleTabArt_SetMeasuringFont cobj__obj  cobj__font  
foreign import ccall "wxAuiSimpleTabArt_SetMeasuringFont" wxAuiSimpleTabArt_SetMeasuringFont :: Ptr (TAuiSimpleTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiSimpleTabArtSetNormalFont obj font@).
auiSimpleTabArtSetNormalFont :: AuiSimpleTabArt  a -> Font  b ->  IO ()
auiSimpleTabArtSetNormalFont _obj _font 
  = withObjectRef "auiSimpleTabArtSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiSimpleTabArt_SetNormalFont cobj__obj  cobj__font  
foreign import ccall "wxAuiSimpleTabArt_SetNormalFont" wxAuiSimpleTabArt_SetNormalFont :: Ptr (TAuiSimpleTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiSimpleTabArtSetSelectedFont obj font@).
auiSimpleTabArtSetSelectedFont :: AuiSimpleTabArt  a -> Font  b ->  IO ()
auiSimpleTabArtSetSelectedFont _obj _font 
  = withObjectRef "auiSimpleTabArtSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiSimpleTabArt_SetSelectedFont cobj__obj  cobj__font  
foreign import ccall "wxAuiSimpleTabArt_SetSelectedFont" wxAuiSimpleTabArt_SetSelectedFont :: Ptr (TAuiSimpleTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiSimpleTabArtSetSizingInfo obj widthheight tabCount@).
auiSimpleTabArtSetSizingInfo :: AuiSimpleTabArt  a -> Size -> Int ->  IO ()
auiSimpleTabArtSetSizingInfo _obj _widthheight tabCount 
  = withObjectRef "auiSimpleTabArtSetSizingInfo" _obj $ \cobj__obj -> 
    wxAuiSimpleTabArt_SetSizingInfo cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt tabCount)  
foreign import ccall "wxAuiSimpleTabArt_SetSizingInfo" wxAuiSimpleTabArt_SetSizingInfo :: Ptr (TAuiSimpleTabArt a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@auiSimpleTabArtShowDropDown obj wnd items activeIdx@).
auiSimpleTabArtShowDropDown :: AuiSimpleTabArt  a -> Window  b -> AuiNotebookPageArray  c -> Int ->  IO Int
auiSimpleTabArtShowDropDown _obj _wnd _items activeIdx 
  = withIntResult $
    withObjectRef "auiSimpleTabArtShowDropDown" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _items $ \cobj__items -> 
    wxAuiSimpleTabArt_ShowDropDown cobj__obj  cobj__wnd  cobj__items  (toCInt activeIdx)  
foreign import ccall "wxAuiSimpleTabArt_ShowDropDown" wxAuiSimpleTabArt_ShowDropDown :: Ptr (TAuiSimpleTabArt a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPageArray c) -> CInt -> IO CInt

-- | usage: (@auiTabArtClone obj@).
auiTabArtClone :: AuiTabArt  a ->  IO (AuiTabArt  ())
auiTabArtClone _obj 
  = withObjectResult $
    withObjectRef "auiTabArtClone" _obj $ \cobj__obj -> 
    wxAuiTabArt_Clone cobj__obj  
foreign import ccall "wxAuiTabArt_Clone" wxAuiTabArt_Clone :: Ptr (TAuiTabArt a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiTabArtDrawBackground obj dc wnd rect@).
auiTabArtDrawBackground :: AuiTabArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiTabArtDrawBackground _obj _dc _wnd _rect 
  = withObjectRef "auiTabArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiTabArt_DrawBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiTabArt_DrawBackground" wxAuiTabArt_DrawBackground :: Ptr (TAuiTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiTabArtDrawButton obj dc wnd inrect bitmapid buttonstate orientation outrect@).
auiTabArtDrawButton :: AuiTabArt  a -> DC  b -> Window  c -> Rect -> Int -> Int -> Int -> Rect ->  IO ()
auiTabArtDrawButton _obj _dc _wnd _inrect bitmapid buttonstate orientation _outrect 
  = withObjectRef "auiTabArtDrawButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _inrect $ \cobj__inrect -> 
    withWxRectPtr _outrect $ \cobj__outrect -> 
    wxAuiTabArt_DrawButton cobj__obj  cobj__dc  cobj__wnd  cobj__inrect  (toCInt bitmapid)  (toCInt buttonstate)  (toCInt orientation)  cobj__outrect  
foreign import ccall "wxAuiTabArt_DrawButton" wxAuiTabArt_DrawButton :: Ptr (TAuiTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> CInt -> CInt -> CInt -> Ptr (TWxRect h) -> IO ()

-- | usage: (@auiTabArtDrawTab obj dc wnd page rect closebuttonstate outtabrect outbuttonrect xextent@).
auiTabArtDrawTab :: AuiTabArt  a -> DC  b -> Window  c -> AuiNotebookPage  d -> Rect -> Int -> Rect -> Rect -> Ptr CInt ->  IO ()
auiTabArtDrawTab _obj _dc _wnd _page _rect closebuttonstate _outtabrect _outbuttonrect xextent 
  = withObjectRef "auiTabArtDrawTab" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _page $ \cobj__page -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    withWxRectPtr _outtabrect $ \cobj__outtabrect -> 
    withWxRectPtr _outbuttonrect $ \cobj__outbuttonrect -> 
    wxAuiTabArt_DrawTab cobj__obj  cobj__dc  cobj__wnd  cobj__page  cobj__rect  (toCInt closebuttonstate)  cobj__outtabrect  cobj__outbuttonrect  xextent  
foreign import ccall "wxAuiTabArt_DrawTab" wxAuiTabArt_DrawTab :: Ptr (TAuiTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiNotebookPage d) -> Ptr (TWxRect e) -> CInt -> Ptr (TWxRect g) -> Ptr (TWxRect h) -> Ptr CInt -> IO ()

-- | usage: (@auiTabArtGetBestTabCtrlSize obj wnd pages widthheight@).
auiTabArtGetBestTabCtrlSize :: AuiTabArt  a -> Window  b -> AuiNotebookPageArray  c -> Size ->  IO Int
auiTabArtGetBestTabCtrlSize _obj _wnd _pages _widthheight 
  = withIntResult $
    withObjectRef "auiTabArtGetBestTabCtrlSize" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _pages $ \cobj__pages -> 
    wxAuiTabArt_GetBestTabCtrlSize cobj__obj  cobj__wnd  cobj__pages  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiTabArt_GetBestTabCtrlSize" wxAuiTabArt_GetBestTabCtrlSize :: Ptr (TAuiTabArt a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPageArray c) -> CInt -> CInt -> IO CInt

-- | usage: (@auiTabArtGetIndentSize obj@).
auiTabArtGetIndentSize :: AuiTabArt  a ->  IO Int
auiTabArtGetIndentSize _obj 
  = withIntResult $
    withObjectRef "auiTabArtGetIndentSize" _obj $ \cobj__obj -> 
    wxAuiTabArt_GetIndentSize cobj__obj  
foreign import ccall "wxAuiTabArt_GetIndentSize" wxAuiTabArt_GetIndentSize :: Ptr (TAuiTabArt a) -> IO CInt

-- | usage: (@auiTabArtGetTabSize obj dc wnd caption bitmap active closebuttonstate xextent@).
auiTabArtGetTabSize :: AuiTabArt  a -> DC  b -> Window  c -> String -> Bitmap  e -> Bool -> Int -> Ptr CInt ->  IO (Size)
auiTabArtGetTabSize _obj _dc _wnd _caption _bitmap active closebuttonstate xextent 
  = withWxSizeResult $
    withObjectRef "auiTabArtGetTabSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withStringPtr _caption $ \cobj__caption -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiTabArt_GetTabSize cobj__obj  cobj__dc  cobj__wnd  cobj__caption  cobj__bitmap  (toCBool active)  (toCInt closebuttonstate)  xextent  
foreign import ccall "wxAuiTabArt_GetTabSize" wxAuiTabArt_GetTabSize :: Ptr (TAuiTabArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxString d) -> Ptr (TBitmap e) -> CBool -> CInt -> Ptr CInt -> IO (Ptr (TWxSize ()))

-- | usage: (@auiTabArtSetActiveColour obj colour@).
auiTabArtSetActiveColour :: AuiTabArt  a -> Color ->  IO ()
auiTabArtSetActiveColour _obj _colour 
  = withObjectRef "auiTabArtSetActiveColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabArt_SetActiveColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabArt_SetActiveColour" wxAuiTabArt_SetActiveColour :: Ptr (TAuiTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabArtSetColour obj colour@).
auiTabArtSetColour :: AuiTabArt  a -> Color ->  IO ()
auiTabArtSetColour _obj _colour 
  = withObjectRef "auiTabArtSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabArt_SetColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabArt_SetColour" wxAuiTabArt_SetColour :: Ptr (TAuiTabArt a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabArtSetFlags obj flags@).
auiTabArtSetFlags :: AuiTabArt  a -> Int ->  IO ()
auiTabArtSetFlags _obj _flags 
  = withObjectRef "auiTabArtSetFlags" _obj $ \cobj__obj -> 
    wxAuiTabArt_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiTabArt_SetFlags" wxAuiTabArt_SetFlags :: Ptr (TAuiTabArt a) -> CInt -> IO ()

-- | usage: (@auiTabArtSetMeasuringFont obj font@).
auiTabArtSetMeasuringFont :: AuiTabArt  a -> Font  b ->  IO ()
auiTabArtSetMeasuringFont _obj _font 
  = withObjectRef "auiTabArtSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiTabArt_SetMeasuringFont cobj__obj  cobj__font  
foreign import ccall "wxAuiTabArt_SetMeasuringFont" wxAuiTabArt_SetMeasuringFont :: Ptr (TAuiTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabArtSetNormalFont obj font@).
auiTabArtSetNormalFont :: AuiTabArt  a -> Font  b ->  IO ()
auiTabArtSetNormalFont _obj _font 
  = withObjectRef "auiTabArtSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiTabArt_SetNormalFont cobj__obj  cobj__font  
foreign import ccall "wxAuiTabArt_SetNormalFont" wxAuiTabArt_SetNormalFont :: Ptr (TAuiTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabArtSetSelectedFont obj font@).
auiTabArtSetSelectedFont :: AuiTabArt  a -> Font  b ->  IO ()
auiTabArtSetSelectedFont _obj _font 
  = withObjectRef "auiTabArtSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiTabArt_SetSelectedFont cobj__obj  cobj__font  
foreign import ccall "wxAuiTabArt_SetSelectedFont" wxAuiTabArt_SetSelectedFont :: Ptr (TAuiTabArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabArtSetSizingInfo obj widthheight tabcount@).
auiTabArtSetSizingInfo :: AuiTabArt  a -> Size -> Int ->  IO ()
auiTabArtSetSizingInfo _obj _widthheight tabcount 
  = withObjectRef "auiTabArtSetSizingInfo" _obj $ \cobj__obj -> 
    wxAuiTabArt_SetSizingInfo cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt tabcount)  
foreign import ccall "wxAuiTabArt_SetSizingInfo" wxAuiTabArt_SetSizingInfo :: Ptr (TAuiTabArt a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@auiTabContainerAddButton obj id location normalBitmap disabledBitmap@).
auiTabContainerAddButton :: AuiTabContainer  a -> Id -> Int -> Bitmap  d -> Bitmap  e ->  IO ()
auiTabContainerAddButton _obj id location _normalBitmap _disabledBitmap 
  = withObjectRef "auiTabContainerAddButton" _obj $ \cobj__obj -> 
    withObjectPtr _normalBitmap $ \cobj__normalBitmap -> 
    withObjectPtr _disabledBitmap $ \cobj__disabledBitmap -> 
    wxAuiTabContainer_AddButton cobj__obj  (toCInt id)  (toCInt location)  cobj__normalBitmap  cobj__disabledBitmap  
foreign import ccall "wxAuiTabContainer_AddButton" wxAuiTabContainer_AddButton :: Ptr (TAuiTabContainer a) -> CInt -> CInt -> Ptr (TBitmap d) -> Ptr (TBitmap e) -> IO ()

-- | usage: (@auiTabContainerAddPage obj page info@).
auiTabContainerAddPage :: AuiTabContainer  a -> Window  b -> AuiNotebookPage  c ->  IO Bool
auiTabContainerAddPage _obj _page _info 
  = withBoolResult $
    withObjectRef "auiTabContainerAddPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withObjectPtr _info $ \cobj__info -> 
    wxAuiTabContainer_AddPage cobj__obj  cobj__page  cobj__info  
foreign import ccall "wxAuiTabContainer_AddPage" wxAuiTabContainer_AddPage :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPage c) -> IO CBool

-- | usage: (@auiTabContainerButtonBitmap obj@).
auiTabContainerButtonBitmap :: AuiTabContainerButton  a ->  IO (Bitmap  ())
auiTabContainerButtonBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiTabContainerButtonBitmap" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_Bitmap cobj__obj   pref
foreign import ccall "wxAuiTabContainerButton_Bitmap" wxAuiTabContainerButton_Bitmap :: Ptr (TAuiTabContainerButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiTabContainerButtonCurState obj@).
auiTabContainerButtonCurState :: AuiTabContainerButton  a ->  IO Int
auiTabContainerButtonCurState _obj 
  = withIntResult $
    withObjectRef "auiTabContainerButtonCurState" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_CurState cobj__obj  
foreign import ccall "wxAuiTabContainerButton_CurState" wxAuiTabContainerButton_CurState :: Ptr (TAuiTabContainerButton a) -> IO CInt

-- | usage: (@auiTabContainerButtonDisBitmap obj@).
auiTabContainerButtonDisBitmap :: AuiTabContainerButton  a ->  IO (Bitmap  ())
auiTabContainerButtonDisBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiTabContainerButtonDisBitmap" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_DisBitmap cobj__obj   pref
foreign import ccall "wxAuiTabContainerButton_DisBitmap" wxAuiTabContainerButton_DisBitmap :: Ptr (TAuiTabContainerButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiTabContainerButtonId obj@).
auiTabContainerButtonId :: AuiTabContainerButton  a ->  IO Int
auiTabContainerButtonId _obj 
  = withIntResult $
    withObjectRef "auiTabContainerButtonId" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_Id cobj__obj  
foreign import ccall "wxAuiTabContainerButton_Id" wxAuiTabContainerButton_Id :: Ptr (TAuiTabContainerButton a) -> IO CInt

-- | usage: (@auiTabContainerButtonLocation obj@).
auiTabContainerButtonLocation :: AuiTabContainerButton  a ->  IO Int
auiTabContainerButtonLocation _obj 
  = withIntResult $
    withObjectRef "auiTabContainerButtonLocation" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_Location cobj__obj  
foreign import ccall "wxAuiTabContainerButton_Location" wxAuiTabContainerButton_Location :: Ptr (TAuiTabContainerButton a) -> IO CInt

-- | usage: (@auiTabContainerButtonRect obj@).
auiTabContainerButtonRect :: AuiTabContainerButton  a ->  IO (Rect)
auiTabContainerButtonRect _obj 
  = withWxRectResult $
    withObjectRef "auiTabContainerButtonRect" _obj $ \cobj__obj -> 
    wxAuiTabContainerButton_Rect cobj__obj  
foreign import ccall "wxAuiTabContainerButton_Rect" wxAuiTabContainerButton_Rect :: Ptr (TAuiTabContainerButton a) -> IO (Ptr (TWxRect ()))

-- | usage: (@auiTabContainerCreate@).
auiTabContainerCreate ::  IO (AuiTabContainer  ())
auiTabContainerCreate 
  = withObjectResult $
    wxAuiTabContainer_Create 
foreign import ccall "wxAuiTabContainer_Create" wxAuiTabContainer_Create :: IO (Ptr (TAuiTabContainer ()))

-- | usage: (@auiTabContainerDoShowHide obj@).
auiTabContainerDoShowHide :: AuiTabContainer  a ->  IO ()
auiTabContainerDoShowHide _obj 
  = withObjectRef "auiTabContainerDoShowHide" _obj $ \cobj__obj -> 
    wxAuiTabContainer_DoShowHide cobj__obj  
foreign import ccall "wxAuiTabContainer_DoShowHide" wxAuiTabContainer_DoShowHide :: Ptr (TAuiTabContainer a) -> IO ()

-- | usage: (@auiTabContainerGetActivePage obj@).
auiTabContainerGetActivePage :: AuiTabContainer  a ->  IO Int
auiTabContainerGetActivePage _obj 
  = withIntResult $
    withObjectRef "auiTabContainerGetActivePage" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetActivePage cobj__obj  
foreign import ccall "wxAuiTabContainer_GetActivePage" wxAuiTabContainer_GetActivePage :: Ptr (TAuiTabContainer a) -> IO CInt

-- | usage: (@auiTabContainerGetArtProvider obj@).
auiTabContainerGetArtProvider :: AuiTabContainer  a ->  IO (AuiTabArt  ())
auiTabContainerGetArtProvider _obj 
  = withObjectResult $
    withObjectRef "auiTabContainerGetArtProvider" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetArtProvider cobj__obj  
foreign import ccall "wxAuiTabContainer_GetArtProvider" wxAuiTabContainer_GetArtProvider :: Ptr (TAuiTabContainer a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiTabContainerGetFlags obj@).
auiTabContainerGetFlags :: AuiTabContainer  a ->  IO Int
auiTabContainerGetFlags _obj 
  = withIntResult $
    withObjectRef "auiTabContainerGetFlags" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetFlags cobj__obj  
foreign import ccall "wxAuiTabContainer_GetFlags" wxAuiTabContainer_GetFlags :: Ptr (TAuiTabContainer a) -> IO CInt

-- | usage: (@auiTabContainerGetIdxFromWindow obj page@).
auiTabContainerGetIdxFromWindow :: AuiTabContainer  a -> Window  b ->  IO Int
auiTabContainerGetIdxFromWindow _obj _page 
  = withIntResult $
    withObjectRef "auiTabContainerGetIdxFromWindow" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabContainer_GetIdxFromWindow cobj__obj  cobj__page  
foreign import ccall "wxAuiTabContainer_GetIdxFromWindow" wxAuiTabContainer_GetIdxFromWindow :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> IO CInt

-- | usage: (@auiTabContainerGetPage obj idx@).
auiTabContainerGetPage :: AuiTabContainer  a -> Int ->  IO (AuiNotebookPage  ())
auiTabContainerGetPage _obj idx 
  = withObjectResult $
    withObjectRef "auiTabContainerGetPage" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetPage cobj__obj  (toCInt idx)  
foreign import ccall "wxAuiTabContainer_GetPage" wxAuiTabContainer_GetPage :: Ptr (TAuiTabContainer a) -> CInt -> IO (Ptr (TAuiNotebookPage ()))

-- | usage: (@auiTabContainerGetPageCount obj@).
auiTabContainerGetPageCount :: AuiTabContainer  a ->  IO Int
auiTabContainerGetPageCount _obj 
  = withIntResult $
    withObjectRef "auiTabContainerGetPageCount" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetPageCount cobj__obj  
foreign import ccall "wxAuiTabContainer_GetPageCount" wxAuiTabContainer_GetPageCount :: Ptr (TAuiTabContainer a) -> IO CInt

-- | usage: (@auiTabContainerGetPages obj@).
auiTabContainerGetPages :: AuiTabContainer  a ->  IO (AuiNotebookPageArray  ())
auiTabContainerGetPages _obj 
  = withObjectResult $
    withObjectRef "auiTabContainerGetPages" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetPages cobj__obj  
foreign import ccall "wxAuiTabContainer_GetPages" wxAuiTabContainer_GetPages :: Ptr (TAuiTabContainer a) -> IO (Ptr (TAuiNotebookPageArray ()))

-- | usage: (@auiTabContainerGetTabOffset obj@).
auiTabContainerGetTabOffset :: AuiTabContainer  a ->  IO Int
auiTabContainerGetTabOffset _obj 
  = withIntResult $
    withObjectRef "auiTabContainerGetTabOffset" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetTabOffset cobj__obj  
foreign import ccall "wxAuiTabContainer_GetTabOffset" wxAuiTabContainer_GetTabOffset :: Ptr (TAuiTabContainer a) -> IO CInt

-- | usage: (@auiTabContainerGetWindowFromIdx obj idx@).
auiTabContainerGetWindowFromIdx :: AuiTabContainer  a -> Int ->  IO (Window  ())
auiTabContainerGetWindowFromIdx _obj idx 
  = withObjectResult $
    withObjectRef "auiTabContainerGetWindowFromIdx" _obj $ \cobj__obj -> 
    wxAuiTabContainer_GetWindowFromIdx cobj__obj  (toCInt idx)  
foreign import ccall "wxAuiTabContainer_GetWindowFromIdx" wxAuiTabContainer_GetWindowFromIdx :: Ptr (TAuiTabContainer a) -> CInt -> IO (Ptr (TWindow ()))

-- | usage: (@auiTabContainerInsertPage obj page info idx@).
auiTabContainerInsertPage :: AuiTabContainer  a -> Window  b -> AuiNotebookPage  c -> Int ->  IO Bool
auiTabContainerInsertPage _obj _page _info idx 
  = withBoolResult $
    withObjectRef "auiTabContainerInsertPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withObjectPtr _info $ \cobj__info -> 
    wxAuiTabContainer_InsertPage cobj__obj  cobj__page  cobj__info  (toCInt idx)  
foreign import ccall "wxAuiTabContainer_InsertPage" wxAuiTabContainer_InsertPage :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPage c) -> CInt -> IO CBool

-- | usage: (@auiTabContainerIsTabVisible obj tabPage tabOffset dc wnd@).
auiTabContainerIsTabVisible :: AuiTabContainer  a -> Int -> Int -> DC  d -> Window  e ->  IO Bool
auiTabContainerIsTabVisible _obj tabPage tabOffset _dc _wnd 
  = withBoolResult $
    withObjectRef "auiTabContainerIsTabVisible" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    wxAuiTabContainer_IsTabVisible cobj__obj  (toCInt tabPage)  (toCInt tabOffset)  cobj__dc  cobj__wnd  
foreign import ccall "wxAuiTabContainer_IsTabVisible" wxAuiTabContainer_IsTabVisible :: Ptr (TAuiTabContainer a) -> CInt -> CInt -> Ptr (TDC d) -> Ptr (TWindow e) -> IO CBool

-- | usage: (@auiTabContainerMakeTabVisible obj tabPage win@).
auiTabContainerMakeTabVisible :: AuiTabContainer  a -> Int -> Window  c ->  IO ()
auiTabContainerMakeTabVisible _obj tabPage _win 
  = withObjectRef "auiTabContainerMakeTabVisible" _obj $ \cobj__obj -> 
    withObjectPtr _win $ \cobj__win -> 
    wxAuiTabContainer_MakeTabVisible cobj__obj  (toCInt tabPage)  cobj__win  
foreign import ccall "wxAuiTabContainer_MakeTabVisible" wxAuiTabContainer_MakeTabVisible :: Ptr (TAuiTabContainer a) -> CInt -> Ptr (TWindow c) -> IO ()

-- | usage: (@auiTabContainerMovePage obj page newIdx@).
auiTabContainerMovePage :: AuiTabContainer  a -> Window  b -> Int ->  IO Bool
auiTabContainerMovePage _obj _page newIdx 
  = withBoolResult $
    withObjectRef "auiTabContainerMovePage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabContainer_MovePage cobj__obj  cobj__page  (toCInt newIdx)  
foreign import ccall "wxAuiTabContainer_MovePage" wxAuiTabContainer_MovePage :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> CInt -> IO CBool

-- | usage: (@auiTabContainerRemoveButton obj id@).
auiTabContainerRemoveButton :: AuiTabContainer  a -> Id ->  IO ()
auiTabContainerRemoveButton _obj id 
  = withObjectRef "auiTabContainerRemoveButton" _obj $ \cobj__obj -> 
    wxAuiTabContainer_RemoveButton cobj__obj  (toCInt id)  
foreign import ccall "wxAuiTabContainer_RemoveButton" wxAuiTabContainer_RemoveButton :: Ptr (TAuiTabContainer a) -> CInt -> IO ()

-- | usage: (@auiTabContainerRemovePage obj page@).
auiTabContainerRemovePage :: AuiTabContainer  a -> Window  b ->  IO Bool
auiTabContainerRemovePage _obj _page 
  = withBoolResult $
    withObjectRef "auiTabContainerRemovePage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabContainer_RemovePage cobj__obj  cobj__page  
foreign import ccall "wxAuiTabContainer_RemovePage" wxAuiTabContainer_RemovePage :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@auiTabContainerSetActiveColour obj colour@).
auiTabContainerSetActiveColour :: AuiTabContainer  a -> Color ->  IO ()
auiTabContainerSetActiveColour _obj _colour 
  = withObjectRef "auiTabContainerSetActiveColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabContainer_SetActiveColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabContainer_SetActiveColour" wxAuiTabContainer_SetActiveColour :: Ptr (TAuiTabContainer a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabContainerSetActivePage obj page@).
auiTabContainerSetActivePage :: AuiTabContainer  a -> Int ->  IO Bool
auiTabContainerSetActivePage _obj page 
  = withBoolResult $
    withObjectRef "auiTabContainerSetActivePage" _obj $ \cobj__obj -> 
    wxAuiTabContainer_SetActivePage cobj__obj  (toCInt page)  
foreign import ccall "wxAuiTabContainer_SetActivePage" wxAuiTabContainer_SetActivePage :: Ptr (TAuiTabContainer a) -> CInt -> IO CBool

-- | usage: (@auiTabContainerSetActivePageByWindow obj page@).
auiTabContainerSetActivePageByWindow :: AuiTabContainer  a -> Window  b ->  IO Bool
auiTabContainerSetActivePageByWindow _obj _page 
  = withBoolResult $
    withObjectRef "auiTabContainerSetActivePageByWindow" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabContainer_SetActivePageByWindow cobj__obj  cobj__page  
foreign import ccall "wxAuiTabContainer_SetActivePageByWindow" wxAuiTabContainer_SetActivePageByWindow :: Ptr (TAuiTabContainer a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@auiTabContainerSetArtProvider obj art@).
auiTabContainerSetArtProvider :: AuiTabContainer  a -> AuiTabArt  b ->  IO ()
auiTabContainerSetArtProvider _obj _art 
  = withObjectRef "auiTabContainerSetArtProvider" _obj $ \cobj__obj -> 
    withObjectPtr _art $ \cobj__art -> 
    wxAuiTabContainer_SetArtProvider cobj__obj  cobj__art  
foreign import ccall "wxAuiTabContainer_SetArtProvider" wxAuiTabContainer_SetArtProvider :: Ptr (TAuiTabContainer a) -> Ptr (TAuiTabArt b) -> IO ()

-- | usage: (@auiTabContainerSetColour obj colour@).
auiTabContainerSetColour :: AuiTabContainer  a -> Color ->  IO ()
auiTabContainerSetColour _obj _colour 
  = withObjectRef "auiTabContainerSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabContainer_SetColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabContainer_SetColour" wxAuiTabContainer_SetColour :: Ptr (TAuiTabContainer a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabContainerSetFlags obj flags@).
auiTabContainerSetFlags :: AuiTabContainer  a -> Int ->  IO ()
auiTabContainerSetFlags _obj _flags 
  = withObjectRef "auiTabContainerSetFlags" _obj $ \cobj__obj -> 
    wxAuiTabContainer_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiTabContainer_SetFlags" wxAuiTabContainer_SetFlags :: Ptr (TAuiTabContainer a) -> CInt -> IO ()

-- | usage: (@auiTabContainerSetMeasuringFont obj measuringFont@).
auiTabContainerSetMeasuringFont :: AuiTabContainer  a -> Font  b ->  IO ()
auiTabContainerSetMeasuringFont _obj _measuringFont 
  = withObjectRef "auiTabContainerSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _measuringFont $ \cobj__measuringFont -> 
    wxAuiTabContainer_SetMeasuringFont cobj__obj  cobj__measuringFont  
foreign import ccall "wxAuiTabContainer_SetMeasuringFont" wxAuiTabContainer_SetMeasuringFont :: Ptr (TAuiTabContainer a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabContainerSetNoneActive obj@).
auiTabContainerSetNoneActive :: AuiTabContainer  a ->  IO ()
auiTabContainerSetNoneActive _obj 
  = withObjectRef "auiTabContainerSetNoneActive" _obj $ \cobj__obj -> 
    wxAuiTabContainer_SetNoneActive cobj__obj  
foreign import ccall "wxAuiTabContainer_SetNoneActive" wxAuiTabContainer_SetNoneActive :: Ptr (TAuiTabContainer a) -> IO ()

-- | usage: (@auiTabContainerSetNormalFont obj normalFont@).
auiTabContainerSetNormalFont :: AuiTabContainer  a -> Font  b ->  IO ()
auiTabContainerSetNormalFont _obj _normalFont 
  = withObjectRef "auiTabContainerSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _normalFont $ \cobj__normalFont -> 
    wxAuiTabContainer_SetNormalFont cobj__obj  cobj__normalFont  
foreign import ccall "wxAuiTabContainer_SetNormalFont" wxAuiTabContainer_SetNormalFont :: Ptr (TAuiTabContainer a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabContainerSetRect obj rect@).
auiTabContainerSetRect :: AuiTabContainer  a -> Rect ->  IO ()
auiTabContainerSetRect _obj _rect 
  = withObjectRef "auiTabContainerSetRect" _obj $ \cobj__obj -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiTabContainer_SetRect cobj__obj  cobj__rect  
foreign import ccall "wxAuiTabContainer_SetRect" wxAuiTabContainer_SetRect :: Ptr (TAuiTabContainer a) -> Ptr (TWxRect b) -> IO ()

-- | usage: (@auiTabContainerSetSelectedFont obj selectedFont@).
auiTabContainerSetSelectedFont :: AuiTabContainer  a -> Font  b ->  IO ()
auiTabContainerSetSelectedFont _obj _selectedFont 
  = withObjectRef "auiTabContainerSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _selectedFont $ \cobj__selectedFont -> 
    wxAuiTabContainer_SetSelectedFont cobj__obj  cobj__selectedFont  
foreign import ccall "wxAuiTabContainer_SetSelectedFont" wxAuiTabContainer_SetSelectedFont :: Ptr (TAuiTabContainer a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabContainerSetTabOffset obj offset@).
auiTabContainerSetTabOffset :: AuiTabContainer  a -> Int ->  IO ()
auiTabContainerSetTabOffset _obj offset 
  = withObjectRef "auiTabContainerSetTabOffset" _obj $ \cobj__obj -> 
    wxAuiTabContainer_SetTabOffset cobj__obj  (toCInt offset)  
foreign import ccall "wxAuiTabContainer_SetTabOffset" wxAuiTabContainer_SetTabOffset :: Ptr (TAuiTabContainer a) -> CInt -> IO ()

-- | usage: (@auiTabCtrlAddButton obj id location normalBitmap disabledBitmap@).
auiTabCtrlAddButton :: AuiTabCtrl  a -> Id -> Int -> Bitmap  d -> Bitmap  e ->  IO ()
auiTabCtrlAddButton _obj id location _normalBitmap _disabledBitmap 
  = withObjectRef "auiTabCtrlAddButton" _obj $ \cobj__obj -> 
    withObjectPtr _normalBitmap $ \cobj__normalBitmap -> 
    withObjectPtr _disabledBitmap $ \cobj__disabledBitmap -> 
    wxAuiTabCtrl_AddButton cobj__obj  (toCInt id)  (toCInt location)  cobj__normalBitmap  cobj__disabledBitmap  
foreign import ccall "wxAuiTabCtrl_AddButton" wxAuiTabCtrl_AddButton :: Ptr (TAuiTabCtrl a) -> CInt -> CInt -> Ptr (TBitmap d) -> Ptr (TBitmap e) -> IO ()

-- | usage: (@auiTabCtrlAddPage obj page info@).
auiTabCtrlAddPage :: AuiTabCtrl  a -> Window  b -> AuiNotebookPage  c ->  IO Bool
auiTabCtrlAddPage _obj _page _info 
  = withBoolResult $
    withObjectRef "auiTabCtrlAddPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withObjectPtr _info $ \cobj__info -> 
    wxAuiTabCtrl_AddPage cobj__obj  cobj__page  cobj__info  
foreign import ccall "wxAuiTabCtrl_AddPage" wxAuiTabCtrl_AddPage :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPage c) -> IO CBool

-- | usage: (@auiTabCtrlDoShowHide obj@).
auiTabCtrlDoShowHide :: AuiTabCtrl  a ->  IO ()
auiTabCtrlDoShowHide _obj 
  = withObjectRef "auiTabCtrlDoShowHide" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_DoShowHide cobj__obj  
foreign import ccall "wxAuiTabCtrl_DoShowHide" wxAuiTabCtrl_DoShowHide :: Ptr (TAuiTabCtrl a) -> IO ()

-- | usage: (@auiTabCtrlGetActivePage obj@).
auiTabCtrlGetActivePage :: AuiTabCtrl  a ->  IO Int
auiTabCtrlGetActivePage _obj 
  = withIntResult $
    withObjectRef "auiTabCtrlGetActivePage" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetActivePage cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetActivePage" wxAuiTabCtrl_GetActivePage :: Ptr (TAuiTabCtrl a) -> IO CInt

-- | usage: (@auiTabCtrlGetArtProvider obj@).
auiTabCtrlGetArtProvider :: AuiTabCtrl  a ->  IO (AuiTabArt  ())
auiTabCtrlGetArtProvider _obj 
  = withObjectResult $
    withObjectRef "auiTabCtrlGetArtProvider" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetArtProvider cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetArtProvider" wxAuiTabCtrl_GetArtProvider :: Ptr (TAuiTabCtrl a) -> IO (Ptr (TAuiTabArt ()))

-- | usage: (@auiTabCtrlGetFlags obj@).
auiTabCtrlGetFlags :: AuiTabCtrl  a ->  IO Int
auiTabCtrlGetFlags _obj 
  = withIntResult $
    withObjectRef "auiTabCtrlGetFlags" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetFlags cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetFlags" wxAuiTabCtrl_GetFlags :: Ptr (TAuiTabCtrl a) -> IO CInt

-- | usage: (@auiTabCtrlGetIdxFromWindow obj page@).
auiTabCtrlGetIdxFromWindow :: AuiTabCtrl  a -> Window  b ->  IO Int
auiTabCtrlGetIdxFromWindow _obj _page 
  = withIntResult $
    withObjectRef "auiTabCtrlGetIdxFromWindow" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabCtrl_GetIdxFromWindow cobj__obj  cobj__page  
foreign import ccall "wxAuiTabCtrl_GetIdxFromWindow" wxAuiTabCtrl_GetIdxFromWindow :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> IO CInt

-- | usage: (@auiTabCtrlGetPage obj idx@).
auiTabCtrlGetPage :: AuiTabCtrl  a -> Int ->  IO (AuiNotebookPage  ())
auiTabCtrlGetPage _obj idx 
  = withObjectResult $
    withObjectRef "auiTabCtrlGetPage" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetPage cobj__obj  (toCInt idx)  
foreign import ccall "wxAuiTabCtrl_GetPage" wxAuiTabCtrl_GetPage :: Ptr (TAuiTabCtrl a) -> CInt -> IO (Ptr (TAuiNotebookPage ()))

-- | usage: (@auiTabCtrlGetPageCount obj@).
auiTabCtrlGetPageCount :: AuiTabCtrl  a ->  IO Int
auiTabCtrlGetPageCount _obj 
  = withIntResult $
    withObjectRef "auiTabCtrlGetPageCount" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetPageCount cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetPageCount" wxAuiTabCtrl_GetPageCount :: Ptr (TAuiTabCtrl a) -> IO CInt

-- | usage: (@auiTabCtrlGetPages obj@).
auiTabCtrlGetPages :: AuiTabCtrl  a ->  IO (AuiNotebookPageArray  ())
auiTabCtrlGetPages _obj 
  = withObjectResult $
    withObjectRef "auiTabCtrlGetPages" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetPages cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetPages" wxAuiTabCtrl_GetPages :: Ptr (TAuiTabCtrl a) -> IO (Ptr (TAuiNotebookPageArray ()))

-- | usage: (@auiTabCtrlGetTabOffset obj@).
auiTabCtrlGetTabOffset :: AuiTabCtrl  a ->  IO Int
auiTabCtrlGetTabOffset _obj 
  = withIntResult $
    withObjectRef "auiTabCtrlGetTabOffset" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetTabOffset cobj__obj  
foreign import ccall "wxAuiTabCtrl_GetTabOffset" wxAuiTabCtrl_GetTabOffset :: Ptr (TAuiTabCtrl a) -> IO CInt

-- | usage: (@auiTabCtrlGetWindowFromIdx obj idx@).
auiTabCtrlGetWindowFromIdx :: AuiTabCtrl  a -> Int ->  IO (Window  ())
auiTabCtrlGetWindowFromIdx _obj idx 
  = withObjectResult $
    withObjectRef "auiTabCtrlGetWindowFromIdx" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_GetWindowFromIdx cobj__obj  (toCInt idx)  
foreign import ccall "wxAuiTabCtrl_GetWindowFromIdx" wxAuiTabCtrl_GetWindowFromIdx :: Ptr (TAuiTabCtrl a) -> CInt -> IO (Ptr (TWindow ()))

-- | usage: (@auiTabCtrlInsertPage obj page info idx@).
auiTabCtrlInsertPage :: AuiTabCtrl  a -> Window  b -> AuiNotebookPage  c -> Int ->  IO Bool
auiTabCtrlInsertPage _obj _page _info idx 
  = withBoolResult $
    withObjectRef "auiTabCtrlInsertPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withObjectPtr _info $ \cobj__info -> 
    wxAuiTabCtrl_InsertPage cobj__obj  cobj__page  cobj__info  (toCInt idx)  
foreign import ccall "wxAuiTabCtrl_InsertPage" wxAuiTabCtrl_InsertPage :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> Ptr (TAuiNotebookPage c) -> CInt -> IO CBool

-- | usage: (@auiTabCtrlIsTabVisible obj tabPage tabOffset dc wnd@).
auiTabCtrlIsTabVisible :: AuiTabCtrl  a -> Int -> Int -> DC  d -> Window  e ->  IO Bool
auiTabCtrlIsTabVisible _obj tabPage tabOffset _dc _wnd 
  = withBoolResult $
    withObjectRef "auiTabCtrlIsTabVisible" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    wxAuiTabCtrl_IsTabVisible cobj__obj  (toCInt tabPage)  (toCInt tabOffset)  cobj__dc  cobj__wnd  
foreign import ccall "wxAuiTabCtrl_IsTabVisible" wxAuiTabCtrl_IsTabVisible :: Ptr (TAuiTabCtrl a) -> CInt -> CInt -> Ptr (TDC d) -> Ptr (TWindow e) -> IO CBool

-- | usage: (@auiTabCtrlMakeTabVisible obj tabPage win@).
auiTabCtrlMakeTabVisible :: AuiTabCtrl  a -> Int -> Window  c ->  IO ()
auiTabCtrlMakeTabVisible _obj tabPage _win 
  = withObjectRef "auiTabCtrlMakeTabVisible" _obj $ \cobj__obj -> 
    withObjectPtr _win $ \cobj__win -> 
    wxAuiTabCtrl_MakeTabVisible cobj__obj  (toCInt tabPage)  cobj__win  
foreign import ccall "wxAuiTabCtrl_MakeTabVisible" wxAuiTabCtrl_MakeTabVisible :: Ptr (TAuiTabCtrl a) -> CInt -> Ptr (TWindow c) -> IO ()

-- | usage: (@auiTabCtrlMovePage obj page newIdx@).
auiTabCtrlMovePage :: AuiTabCtrl  a -> Window  b -> Int ->  IO Bool
auiTabCtrlMovePage _obj _page newIdx 
  = withBoolResult $
    withObjectRef "auiTabCtrlMovePage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabCtrl_MovePage cobj__obj  cobj__page  (toCInt newIdx)  
foreign import ccall "wxAuiTabCtrl_MovePage" wxAuiTabCtrl_MovePage :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> CInt -> IO CBool

-- | usage: (@auiTabCtrlRemoveButton obj id@).
auiTabCtrlRemoveButton :: AuiTabCtrl  a -> Id ->  IO ()
auiTabCtrlRemoveButton _obj id 
  = withObjectRef "auiTabCtrlRemoveButton" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_RemoveButton cobj__obj  (toCInt id)  
foreign import ccall "wxAuiTabCtrl_RemoveButton" wxAuiTabCtrl_RemoveButton :: Ptr (TAuiTabCtrl a) -> CInt -> IO ()

-- | usage: (@auiTabCtrlRemovePage obj page@).
auiTabCtrlRemovePage :: AuiTabCtrl  a -> Window  b ->  IO Bool
auiTabCtrlRemovePage _obj _page 
  = withBoolResult $
    withObjectRef "auiTabCtrlRemovePage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabCtrl_RemovePage cobj__obj  cobj__page  
foreign import ccall "wxAuiTabCtrl_RemovePage" wxAuiTabCtrl_RemovePage :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@auiTabCtrlSetActiveColour obj colour@).
auiTabCtrlSetActiveColour :: AuiTabCtrl  a -> Color ->  IO ()
auiTabCtrlSetActiveColour _obj _colour 
  = withObjectRef "auiTabCtrlSetActiveColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabCtrl_SetActiveColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabCtrl_SetActiveColour" wxAuiTabCtrl_SetActiveColour :: Ptr (TAuiTabCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabCtrlSetActivePage obj page@).
auiTabCtrlSetActivePage :: AuiTabCtrl  a -> Int ->  IO Bool
auiTabCtrlSetActivePage _obj page 
  = withBoolResult $
    withObjectRef "auiTabCtrlSetActivePage" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_SetActivePage cobj__obj  (toCInt page)  
foreign import ccall "wxAuiTabCtrl_SetActivePage" wxAuiTabCtrl_SetActivePage :: Ptr (TAuiTabCtrl a) -> CInt -> IO CBool

-- | usage: (@auiTabCtrlSetActivePageByWindow obj page@).
auiTabCtrlSetActivePageByWindow :: AuiTabCtrl  a -> Window  b ->  IO Bool
auiTabCtrlSetActivePageByWindow _obj _page 
  = withBoolResult $
    withObjectRef "auiTabCtrlSetActivePageByWindow" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxAuiTabCtrl_SetActivePageByWindow cobj__obj  cobj__page  
foreign import ccall "wxAuiTabCtrl_SetActivePageByWindow" wxAuiTabCtrl_SetActivePageByWindow :: Ptr (TAuiTabCtrl a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@auiTabCtrlSetArtProvider obj art@).
auiTabCtrlSetArtProvider :: AuiTabCtrl  a -> AuiTabArt  b ->  IO ()
auiTabCtrlSetArtProvider _obj _art 
  = withObjectRef "auiTabCtrlSetArtProvider" _obj $ \cobj__obj -> 
    withObjectPtr _art $ \cobj__art -> 
    wxAuiTabCtrl_SetArtProvider cobj__obj  cobj__art  
foreign import ccall "wxAuiTabCtrl_SetArtProvider" wxAuiTabCtrl_SetArtProvider :: Ptr (TAuiTabCtrl a) -> Ptr (TAuiTabArt b) -> IO ()

-- | usage: (@auiTabCtrlSetColour obj colour@).
auiTabCtrlSetColour :: AuiTabCtrl  a -> Color ->  IO ()
auiTabCtrlSetColour _obj _colour 
  = withObjectRef "auiTabCtrlSetColour" _obj $ \cobj__obj -> 
    withColourPtr _colour $ \cobj__colour -> 
    wxAuiTabCtrl_SetColour cobj__obj  cobj__colour  
foreign import ccall "wxAuiTabCtrl_SetColour" wxAuiTabCtrl_SetColour :: Ptr (TAuiTabCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@auiTabCtrlSetFlags obj flags@).
auiTabCtrlSetFlags :: AuiTabCtrl  a -> Int ->  IO ()
auiTabCtrlSetFlags _obj _flags 
  = withObjectRef "auiTabCtrlSetFlags" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiTabCtrl_SetFlags" wxAuiTabCtrl_SetFlags :: Ptr (TAuiTabCtrl a) -> CInt -> IO ()

-- | usage: (@auiTabCtrlSetMeasuringFont obj measuringFont@).
auiTabCtrlSetMeasuringFont :: AuiTabCtrl  a -> Font  b ->  IO ()
auiTabCtrlSetMeasuringFont _obj _measuringFont 
  = withObjectRef "auiTabCtrlSetMeasuringFont" _obj $ \cobj__obj -> 
    withObjectPtr _measuringFont $ \cobj__measuringFont -> 
    wxAuiTabCtrl_SetMeasuringFont cobj__obj  cobj__measuringFont  
foreign import ccall "wxAuiTabCtrl_SetMeasuringFont" wxAuiTabCtrl_SetMeasuringFont :: Ptr (TAuiTabCtrl a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabCtrlSetNoneActive obj@).
auiTabCtrlSetNoneActive :: AuiTabCtrl  a ->  IO ()
auiTabCtrlSetNoneActive _obj 
  = withObjectRef "auiTabCtrlSetNoneActive" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_SetNoneActive cobj__obj  
foreign import ccall "wxAuiTabCtrl_SetNoneActive" wxAuiTabCtrl_SetNoneActive :: Ptr (TAuiTabCtrl a) -> IO ()

-- | usage: (@auiTabCtrlSetNormalFont obj normalFont@).
auiTabCtrlSetNormalFont :: AuiTabCtrl  a -> Font  b ->  IO ()
auiTabCtrlSetNormalFont _obj _normalFont 
  = withObjectRef "auiTabCtrlSetNormalFont" _obj $ \cobj__obj -> 
    withObjectPtr _normalFont $ \cobj__normalFont -> 
    wxAuiTabCtrl_SetNormalFont cobj__obj  cobj__normalFont  
foreign import ccall "wxAuiTabCtrl_SetNormalFont" wxAuiTabCtrl_SetNormalFont :: Ptr (TAuiTabCtrl a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabCtrlSetRect obj rect@).
auiTabCtrlSetRect :: AuiTabCtrl  a -> Rect ->  IO ()
auiTabCtrlSetRect _obj _rect 
  = withObjectRef "auiTabCtrlSetRect" _obj $ \cobj__obj -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiTabCtrl_SetRect cobj__obj  cobj__rect  
foreign import ccall "wxAuiTabCtrl_SetRect" wxAuiTabCtrl_SetRect :: Ptr (TAuiTabCtrl a) -> Ptr (TWxRect b) -> IO ()

-- | usage: (@auiTabCtrlSetSelectedFont obj selectedFont@).
auiTabCtrlSetSelectedFont :: AuiTabCtrl  a -> Font  b ->  IO ()
auiTabCtrlSetSelectedFont _obj _selectedFont 
  = withObjectRef "auiTabCtrlSetSelectedFont" _obj $ \cobj__obj -> 
    withObjectPtr _selectedFont $ \cobj__selectedFont -> 
    wxAuiTabCtrl_SetSelectedFont cobj__obj  cobj__selectedFont  
foreign import ccall "wxAuiTabCtrl_SetSelectedFont" wxAuiTabCtrl_SetSelectedFont :: Ptr (TAuiTabCtrl a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiTabCtrlSetTabOffset obj offset@).
auiTabCtrlSetTabOffset :: AuiTabCtrl  a -> Int ->  IO ()
auiTabCtrlSetTabOffset _obj offset 
  = withObjectRef "auiTabCtrlSetTabOffset" _obj $ \cobj__obj -> 
    wxAuiTabCtrl_SetTabOffset cobj__obj  (toCInt offset)  
foreign import ccall "wxAuiTabCtrl_SetTabOffset" wxAuiTabCtrl_SetTabOffset :: Ptr (TAuiTabCtrl a) -> CInt -> IO ()

-- | usage: (@auiToolBarAddControl obj control label@).
auiToolBarAddControl :: AuiToolBar  a -> Control  b -> String ->  IO (AuiToolBarItem  ())
auiToolBarAddControl _obj _control _label 
  = withObjectResult $
    withObjectRef "auiToolBarAddControl" _obj $ \cobj__obj -> 
    withObjectPtr _control $ \cobj__control -> 
    withStringPtr _label $ \cobj__label -> 
    wxAuiToolBar_AddControl cobj__obj  cobj__control  cobj__label  
foreign import ccall "wxAuiToolBar_AddControl" wxAuiToolBar_AddControl :: Ptr (TAuiToolBar a) -> Ptr (TControl b) -> Ptr (TWxString c) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddLabel obj toolid label width@).
auiToolBarAddLabel :: AuiToolBar  a -> Int -> String -> Int ->  IO (AuiToolBarItem  ())
auiToolBarAddLabel _obj toolid _label width 
  = withObjectResult $
    withObjectRef "auiToolBarAddLabel" _obj $ \cobj__obj -> 
    withStringPtr _label $ \cobj__label -> 
    wxAuiToolBar_AddLabel cobj__obj  (toCInt toolid)  cobj__label  (toCInt width)  
foreign import ccall "wxAuiToolBar_AddLabel" wxAuiToolBar_AddLabel :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddSeparator obj@).
auiToolBarAddSeparator :: AuiToolBar  a ->  IO (AuiToolBarItem  ())
auiToolBarAddSeparator _obj 
  = withObjectResult $
    withObjectRef "auiToolBarAddSeparator" _obj $ \cobj__obj -> 
    wxAuiToolBar_AddSeparator cobj__obj  
foreign import ccall "wxAuiToolBar_AddSeparator" wxAuiToolBar_AddSeparator :: Ptr (TAuiToolBar a) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddSpacer obj pixels@).
auiToolBarAddSpacer :: AuiToolBar  a -> Int ->  IO (AuiToolBarItem  ())
auiToolBarAddSpacer _obj pixels 
  = withObjectResult $
    withObjectRef "auiToolBarAddSpacer" _obj $ \cobj__obj -> 
    wxAuiToolBar_AddSpacer cobj__obj  (toCInt pixels)  
foreign import ccall "wxAuiToolBar_AddSpacer" wxAuiToolBar_AddSpacer :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddStretchSpacer obj proportion@).
auiToolBarAddStretchSpacer :: AuiToolBar  a -> Int ->  IO (AuiToolBarItem  ())
auiToolBarAddStretchSpacer _obj proportion 
  = withObjectResult $
    withObjectRef "auiToolBarAddStretchSpacer" _obj $ \cobj__obj -> 
    wxAuiToolBar_AddStretchSpacer cobj__obj  (toCInt proportion)  
foreign import ccall "wxAuiToolBar_AddStretchSpacer" wxAuiToolBar_AddStretchSpacer :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddTool obj toolid label bitmap disabledbitmap kind shorthelpstring longhelpstring clientdata@).
auiToolBarAddTool :: AuiToolBar  a -> Int -> String -> Bitmap  d -> Bitmap  e -> Int -> String -> String -> WxObject  i ->  IO (AuiToolBarItem  ())
auiToolBarAddTool _obj toolid _label _bitmap _disabledbitmap kind _shorthelpstring _longhelpstring _clientdata 
  = withObjectResult $
    withObjectRef "auiToolBarAddTool" _obj $ \cobj__obj -> 
    withStringPtr _label $ \cobj__label -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    withObjectPtr _disabledbitmap $ \cobj__disabledbitmap -> 
    withStringPtr _shorthelpstring $ \cobj__shorthelpstring -> 
    withStringPtr _longhelpstring $ \cobj__longhelpstring -> 
    withObjectPtr _clientdata $ \cobj__clientdata -> 
    wxAuiToolBar_AddTool cobj__obj  (toCInt toolid)  cobj__label  cobj__bitmap  cobj__disabledbitmap  (toCInt kind)  cobj__shorthelpstring  cobj__longhelpstring  cobj__clientdata  
foreign import ccall "wxAuiToolBar_AddTool" wxAuiToolBar_AddTool :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> Ptr (TBitmap d) -> Ptr (TBitmap e) -> CInt -> Ptr (TWxString g) -> Ptr (TWxString h) -> Ptr (TWxObject i) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddToolByBitmap obj toolid bitmap disabledbitmap toggle clientdata shorthelpstring longhelpstring@).
auiToolBarAddToolByBitmap :: AuiToolBar  a -> Int -> Bitmap  c -> Bitmap  d -> Bool -> WxObject  f -> String -> String ->  IO (AuiToolBarItem  ())
auiToolBarAddToolByBitmap _obj toolid _bitmap _disabledbitmap toggle _clientdata _shorthelpstring _longhelpstring 
  = withObjectResult $
    withObjectRef "auiToolBarAddToolByBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    withObjectPtr _disabledbitmap $ \cobj__disabledbitmap -> 
    withObjectPtr _clientdata $ \cobj__clientdata -> 
    withStringPtr _shorthelpstring $ \cobj__shorthelpstring -> 
    withStringPtr _longhelpstring $ \cobj__longhelpstring -> 
    wxAuiToolBar_AddToolByBitmap cobj__obj  (toCInt toolid)  cobj__bitmap  cobj__disabledbitmap  (toCBool toggle)  cobj__clientdata  cobj__shorthelpstring  cobj__longhelpstring  
foreign import ccall "wxAuiToolBar_AddToolByBitmap" wxAuiToolBar_AddToolByBitmap :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TBitmap c) -> Ptr (TBitmap d) -> CBool -> Ptr (TWxObject f) -> Ptr (TWxString g) -> Ptr (TWxString h) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarAddToolByLabel obj toolid label bitmap shorthelpstring kind@).
auiToolBarAddToolByLabel :: AuiToolBar  a -> Int -> String -> Bitmap  d -> String -> Int ->  IO (AuiToolBarItem  ())
auiToolBarAddToolByLabel _obj toolid _label _bitmap _shorthelpstring kind 
  = withObjectResult $
    withObjectRef "auiToolBarAddToolByLabel" _obj $ \cobj__obj -> 
    withStringPtr _label $ \cobj__label -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    withStringPtr _shorthelpstring $ \cobj__shorthelpstring -> 
    wxAuiToolBar_AddToolByLabel cobj__obj  (toCInt toolid)  cobj__label  cobj__bitmap  cobj__shorthelpstring  (toCInt kind)  
foreign import ccall "wxAuiToolBar_AddToolByLabel" wxAuiToolBar_AddToolByLabel :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> Ptr (TBitmap d) -> Ptr (TWxString e) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarArtClone obj@).
auiToolBarArtClone :: AuiToolBarArt  a ->  IO (AuiToolBarArt  ())
auiToolBarArtClone _obj 
  = withObjectResult $
    withObjectRef "auiToolBarArtClone" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_Clone cobj__obj  
foreign import ccall "wxAuiToolBarArt_Clone" wxAuiToolBarArt_Clone :: Ptr (TAuiToolBarArt a) -> IO (Ptr (TAuiToolBarArt ()))

-- | usage: (@auiToolBarArtDrawBackground obj dc wnd rect@).
auiToolBarArtDrawBackground :: AuiToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiToolBarArtDrawBackground _obj _dc _wnd _rect 
  = withObjectRef "auiToolBarArtDrawBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawBackground" wxAuiToolBarArt_DrawBackground :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiToolBarArtDrawButton obj dc wnd item rect@).
auiToolBarArtDrawButton :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiToolBarArtDrawButton _obj _dc _wnd _item _rect 
  = withObjectRef "auiToolBarArtDrawButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawButton cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawButton" wxAuiToolBarArt_DrawButton :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiToolBarArtDrawControlLabel obj dc wnd item rect@).
auiToolBarArtDrawControlLabel :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiToolBarArtDrawControlLabel _obj _dc _wnd _item _rect 
  = withObjectRef "auiToolBarArtDrawControlLabel" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawControlLabel cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawControlLabel" wxAuiToolBarArt_DrawControlLabel :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiToolBarArtDrawDropDownButton obj dc wnd item rect@).
auiToolBarArtDrawDropDownButton :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiToolBarArtDrawDropDownButton _obj _dc _wnd _item _rect 
  = withObjectRef "auiToolBarArtDrawDropDownButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawDropDownButton cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawDropDownButton" wxAuiToolBarArt_DrawDropDownButton :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiToolBarArtDrawGripper obj dc wnd rect@).
auiToolBarArtDrawGripper :: AuiToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiToolBarArtDrawGripper _obj _dc _wnd _rect 
  = withObjectRef "auiToolBarArtDrawGripper" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawGripper cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawGripper" wxAuiToolBarArt_DrawGripper :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiToolBarArtDrawLabel obj dc wnd item rect@).
auiToolBarArtDrawLabel :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d -> Rect ->  IO ()
auiToolBarArtDrawLabel _obj _dc _wnd _item _rect 
  = withObjectRef "auiToolBarArtDrawLabel" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawLabel cobj__obj  cobj__dc  cobj__wnd  cobj__item  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawLabel" wxAuiToolBarArt_DrawLabel :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> Ptr (TWxRect e) -> IO ()

-- | usage: (@auiToolBarArtDrawOverflowButton obj dc wnd rect state@).
auiToolBarArtDrawOverflowButton :: AuiToolBarArt  a -> DC  b -> Window  c -> Rect -> Int ->  IO ()
auiToolBarArtDrawOverflowButton _obj _dc _wnd _rect state 
  = withObjectRef "auiToolBarArtDrawOverflowButton" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawOverflowButton cobj__obj  cobj__dc  cobj__wnd  cobj__rect  (toCInt state)  
foreign import ccall "wxAuiToolBarArt_DrawOverflowButton" wxAuiToolBarArt_DrawOverflowButton :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> CInt -> IO ()

-- | usage: (@auiToolBarArtDrawPlainBackground obj dc wnd rect@).
auiToolBarArtDrawPlainBackground :: AuiToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiToolBarArtDrawPlainBackground _obj _dc _wnd _rect 
  = withObjectRef "auiToolBarArtDrawPlainBackground" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawPlainBackground cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawPlainBackground" wxAuiToolBarArt_DrawPlainBackground :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiToolBarArtDrawSeparator obj dc wnd rect@).
auiToolBarArtDrawSeparator :: AuiToolBarArt  a -> DC  b -> Window  c -> Rect ->  IO ()
auiToolBarArtDrawSeparator _obj _dc _wnd _rect 
  = withObjectRef "auiToolBarArtDrawSeparator" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withWxRectPtr _rect $ \cobj__rect -> 
    wxAuiToolBarArt_DrawSeparator cobj__obj  cobj__dc  cobj__wnd  cobj__rect  
foreign import ccall "wxAuiToolBarArt_DrawSeparator" wxAuiToolBarArt_DrawSeparator :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TWxRect d) -> IO ()

-- | usage: (@auiToolBarArtGetElementSize obj elementid@).
auiToolBarArtGetElementSize :: AuiToolBarArt  a -> Int ->  IO Int
auiToolBarArtGetElementSize _obj elementid 
  = withIntResult $
    withObjectRef "auiToolBarArtGetElementSize" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_GetElementSize cobj__obj  (toCInt elementid)  
foreign import ccall "wxAuiToolBarArt_GetElementSize" wxAuiToolBarArt_GetElementSize :: Ptr (TAuiToolBarArt a) -> CInt -> IO CInt

-- | usage: (@auiToolBarArtGetFlags obj@).
auiToolBarArtGetFlags :: AuiToolBarArt  a ->  IO Int
auiToolBarArtGetFlags _obj 
  = withIntResult $
    withObjectRef "auiToolBarArtGetFlags" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_GetFlags cobj__obj  
foreign import ccall "wxAuiToolBarArt_GetFlags" wxAuiToolBarArt_GetFlags :: Ptr (TAuiToolBarArt a) -> IO CInt

-- | usage: (@auiToolBarArtGetFont obj@).
auiToolBarArtGetFont :: AuiToolBarArt  a ->  IO (Font  ())
auiToolBarArtGetFont _obj 
  = withManagedFontResult $
    withObjectRef "auiToolBarArtGetFont" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_GetFont cobj__obj  
foreign import ccall "wxAuiToolBarArt_GetFont" wxAuiToolBarArt_GetFont :: Ptr (TAuiToolBarArt a) -> IO (Ptr (TFont ()))

-- | usage: (@auiToolBarArtGetLabelSize obj dc wnd item@).
auiToolBarArtGetLabelSize :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d ->  IO (Size)
auiToolBarArtGetLabelSize _obj _dc _wnd _item 
  = withWxSizeResult $
    withObjectRef "auiToolBarArtGetLabelSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    wxAuiToolBarArt_GetLabelSize cobj__obj  cobj__dc  cobj__wnd  cobj__item  
foreign import ccall "wxAuiToolBarArt_GetLabelSize" wxAuiToolBarArt_GetLabelSize :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiToolBarArtGetTextOrientation obj@).
auiToolBarArtGetTextOrientation :: AuiToolBarArt  a ->  IO Int
auiToolBarArtGetTextOrientation _obj 
  = withIntResult $
    withObjectRef "auiToolBarArtGetTextOrientation" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_GetTextOrientation cobj__obj  
foreign import ccall "wxAuiToolBarArt_GetTextOrientation" wxAuiToolBarArt_GetTextOrientation :: Ptr (TAuiToolBarArt a) -> IO CInt

-- | usage: (@auiToolBarArtGetToolSize obj dc wnd item@).
auiToolBarArtGetToolSize :: AuiToolBarArt  a -> DC  b -> Window  c -> AuiToolBarItem  d ->  IO (Size)
auiToolBarArtGetToolSize _obj _dc _wnd _item 
  = withWxSizeResult $
    withObjectRef "auiToolBarArtGetToolSize" _obj $ \cobj__obj -> 
    withObjectPtr _dc $ \cobj__dc -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _item $ \cobj__item -> 
    wxAuiToolBarArt_GetToolSize cobj__obj  cobj__dc  cobj__wnd  cobj__item  
foreign import ccall "wxAuiToolBarArt_GetToolSize" wxAuiToolBarArt_GetToolSize :: Ptr (TAuiToolBarArt a) -> Ptr (TDC b) -> Ptr (TWindow c) -> Ptr (TAuiToolBarItem d) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiToolBarArtSetElementSize obj elementid size@).
auiToolBarArtSetElementSize :: AuiToolBarArt  a -> Int -> Int ->  IO ()
auiToolBarArtSetElementSize _obj elementid size 
  = withObjectRef "auiToolBarArtSetElementSize" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_SetElementSize cobj__obj  (toCInt elementid)  (toCInt size)  
foreign import ccall "wxAuiToolBarArt_SetElementSize" wxAuiToolBarArt_SetElementSize :: Ptr (TAuiToolBarArt a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarArtSetFlags obj flags@).
auiToolBarArtSetFlags :: AuiToolBarArt  a -> Int ->  IO ()
auiToolBarArtSetFlags _obj _flags 
  = withObjectRef "auiToolBarArtSetFlags" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_SetFlags cobj__obj  (toCInt _flags)  
foreign import ccall "wxAuiToolBarArt_SetFlags" wxAuiToolBarArt_SetFlags :: Ptr (TAuiToolBarArt a) -> CInt -> IO ()

-- | usage: (@auiToolBarArtSetFont obj font@).
auiToolBarArtSetFont :: AuiToolBarArt  a -> Font  b ->  IO ()
auiToolBarArtSetFont _obj _font 
  = withObjectRef "auiToolBarArtSetFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiToolBarArt_SetFont cobj__obj  cobj__font  
foreign import ccall "wxAuiToolBarArt_SetFont" wxAuiToolBarArt_SetFont :: Ptr (TAuiToolBarArt a) -> Ptr (TFont b) -> IO ()

-- | usage: (@auiToolBarArtSetTextOrientation obj orientation@).
auiToolBarArtSetTextOrientation :: AuiToolBarArt  a -> Int ->  IO ()
auiToolBarArtSetTextOrientation _obj orientation 
  = withObjectRef "auiToolBarArtSetTextOrientation" _obj $ \cobj__obj -> 
    wxAuiToolBarArt_SetTextOrientation cobj__obj  (toCInt orientation)  
foreign import ccall "wxAuiToolBarArt_SetTextOrientation" wxAuiToolBarArt_SetTextOrientation :: Ptr (TAuiToolBarArt a) -> CInt -> IO ()

-- | usage: (@auiToolBarArtShowDropDown obj wnd items@).
auiToolBarArtShowDropDown :: AuiToolBarArt  a -> Window  b -> AuiToolBarItemArray  c ->  IO Int
auiToolBarArtShowDropDown _obj _wnd _items 
  = withIntResult $
    withObjectRef "auiToolBarArtShowDropDown" _obj $ \cobj__obj -> 
    withObjectPtr _wnd $ \cobj__wnd -> 
    withObjectPtr _items $ \cobj__items -> 
    wxAuiToolBarArt_ShowDropDown cobj__obj  cobj__wnd  cobj__items  
foreign import ccall "wxAuiToolBarArt_ShowDropDown" wxAuiToolBarArt_ShowDropDown :: Ptr (TAuiToolBarArt a) -> Ptr (TWindow b) -> Ptr (TAuiToolBarItemArray c) -> IO CInt

-- | usage: (@auiToolBarClear obj@).
auiToolBarClear :: AuiToolBar  a ->  IO ()
auiToolBarClear _obj 
  = withObjectRef "auiToolBarClear" _obj $ \cobj__obj -> 
    wxAuiToolBar_Clear cobj__obj  
foreign import ccall "wxAuiToolBar_Clear" wxAuiToolBar_Clear :: Ptr (TAuiToolBar a) -> IO ()

-- | usage: (@auiToolBarClearTools obj@).
auiToolBarClearTools :: AuiToolBar  a ->  IO ()
auiToolBarClearTools _obj 
  = withObjectRef "auiToolBarClearTools" _obj $ \cobj__obj -> 
    wxAuiToolBar_ClearTools cobj__obj  
foreign import ccall "wxAuiToolBar_ClearTools" wxAuiToolBar_ClearTools :: Ptr (TAuiToolBar a) -> IO ()

-- | usage: (@auiToolBarCreate parent id xy widthheight style@).
auiToolBarCreate :: Window  a -> Id -> Point -> Size -> Int ->  IO (AuiToolBar  ())
auiToolBarCreate _parent id xy _widthheight style 
  = withObjectResult $
    withObjectPtr _parent $ \cobj__parent -> 
    wxAuiToolBar_Create cobj__parent  (toCInt id)  (toCIntPointX xy) (toCIntPointY xy)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt style)  
foreign import ccall "wxAuiToolBar_Create" wxAuiToolBar_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TAuiToolBar ()))

-- | usage: (@auiToolBarCreateDefault@).
auiToolBarCreateDefault ::  IO (AuiToolBar  ())
auiToolBarCreateDefault 
  = withObjectResult $
    wxAuiToolBar_CreateDefault 
foreign import ccall "wxAuiToolBar_CreateDefault" wxAuiToolBar_CreateDefault :: IO (Ptr (TAuiToolBar ()))

-- | usage: (@auiToolBarCreateFromDefault obj parent id xy widthheight style@).
auiToolBarCreateFromDefault :: AuiToolBar  a -> Window  b -> Id -> Point -> Size -> Int ->  IO Bool
auiToolBarCreateFromDefault _obj _parent id xy _widthheight style 
  = withBoolResult $
    withObjectRef "auiToolBarCreateFromDefault" _obj $ \cobj__obj -> 
    withObjectPtr _parent $ \cobj__parent -> 
    wxAuiToolBar_CreateFromDefault cobj__obj  cobj__parent  (toCInt id)  (toCIntPointX xy) (toCIntPointY xy)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt style)  
foreign import ccall "wxAuiToolBar_CreateFromDefault" wxAuiToolBar_CreateFromDefault :: Ptr (TAuiToolBar a) -> Ptr (TWindow b) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@auiToolBarDelete obj@).
auiToolBarDelete :: AuiToolBar  a ->  IO ()
auiToolBarDelete
  = objectDelete


-- | usage: (@auiToolBarDeleteByIndex obj toolid@).
auiToolBarDeleteByIndex :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarDeleteByIndex _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarDeleteByIndex" _obj $ \cobj__obj -> 
    wxAuiToolBar_DeleteByIndex cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_DeleteByIndex" wxAuiToolBar_DeleteByIndex :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarDeleteTool obj toolid@).
auiToolBarDeleteTool :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarDeleteTool _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarDeleteTool" _obj $ \cobj__obj -> 
    wxAuiToolBar_DeleteTool cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_DeleteTool" wxAuiToolBar_DeleteTool :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarEnableTool obj toolid state@).
auiToolBarEnableTool :: AuiToolBar  a -> Int -> Bool ->  IO ()
auiToolBarEnableTool _obj toolid state 
  = withObjectRef "auiToolBarEnableTool" _obj $ \cobj__obj -> 
    wxAuiToolBar_EnableTool cobj__obj  (toCInt toolid)  (toCBool state)  
foreign import ccall "wxAuiToolBar_EnableTool" wxAuiToolBar_EnableTool :: Ptr (TAuiToolBar a) -> CInt -> CBool -> IO ()

-- | usage: (@auiToolBarEventGetClickPoint obj@).
auiToolBarEventGetClickPoint :: AuiToolBarEvent  a ->  IO (Point)
auiToolBarEventGetClickPoint _obj 
  = withWxPointResult $
    withObjectRef "auiToolBarEventGetClickPoint" _obj $ \cobj__obj -> 
    wxAuiToolBarEvent_GetClickPoint cobj__obj  
foreign import ccall "wxAuiToolBarEvent_GetClickPoint" wxAuiToolBarEvent_GetClickPoint :: Ptr (TAuiToolBarEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@auiToolBarEventGetItemRect obj@).
auiToolBarEventGetItemRect :: AuiToolBarEvent  a ->  IO (Rect)
auiToolBarEventGetItemRect _obj 
  = withWxRectResult $
    withObjectRef "auiToolBarEventGetItemRect" _obj $ \cobj__obj -> 
    wxAuiToolBarEvent_GetItemRect cobj__obj  
foreign import ccall "wxAuiToolBarEvent_GetItemRect" wxAuiToolBarEvent_GetItemRect :: Ptr (TAuiToolBarEvent a) -> IO (Ptr (TWxRect ()))

-- | usage: (@auiToolBarEventGetToolId obj@).
auiToolBarEventGetToolId :: AuiToolBarEvent  a ->  IO Int
auiToolBarEventGetToolId _obj 
  = withIntResult $
    withObjectRef "auiToolBarEventGetToolId" _obj $ \cobj__obj -> 
    wxAuiToolBarEvent_GetToolId cobj__obj  
foreign import ccall "wxAuiToolBarEvent_GetToolId" wxAuiToolBarEvent_GetToolId :: Ptr (TAuiToolBarEvent a) -> IO CInt

-- | usage: (@auiToolBarEventIsDropDownClicked obj@).
auiToolBarEventIsDropDownClicked :: AuiToolBarEvent  a ->  IO Bool
auiToolBarEventIsDropDownClicked _obj 
  = withBoolResult $
    withObjectRef "auiToolBarEventIsDropDownClicked" _obj $ \cobj__obj -> 
    wxAuiToolBarEvent_IsDropDownClicked cobj__obj  
foreign import ccall "wxAuiToolBarEvent_IsDropDownClicked" wxAuiToolBarEvent_IsDropDownClicked :: Ptr (TAuiToolBarEvent a) -> IO CBool

-- | usage: (@auiToolBarFindControl obj windowid@).
auiToolBarFindControl :: AuiToolBar  a -> Int ->  IO (Control  ())
auiToolBarFindControl _obj windowid 
  = withObjectResult $
    withObjectRef "auiToolBarFindControl" _obj $ \cobj__obj -> 
    wxAuiToolBar_FindControl cobj__obj  (toCInt windowid)  
foreign import ccall "wxAuiToolBar_FindControl" wxAuiToolBar_FindControl :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TControl ()))

-- | usage: (@auiToolBarFindTool obj toolid@).
auiToolBarFindTool :: AuiToolBar  a -> Int ->  IO (AuiToolBarItem  ())
auiToolBarFindTool _obj toolid 
  = withObjectResult $
    withObjectRef "auiToolBarFindTool" _obj $ \cobj__obj -> 
    wxAuiToolBar_FindTool cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_FindTool" wxAuiToolBar_FindTool :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarFindToolByIndex obj idx@).
auiToolBarFindToolByIndex :: AuiToolBar  a -> Int ->  IO (AuiToolBarItem  ())
auiToolBarFindToolByIndex _obj idx 
  = withObjectResult $
    withObjectRef "auiToolBarFindToolByIndex" _obj $ \cobj__obj -> 
    wxAuiToolBar_FindToolByIndex cobj__obj  (toCInt idx)  
foreign import ccall "wxAuiToolBar_FindToolByIndex" wxAuiToolBar_FindToolByIndex :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarFindToolByPosition obj xy@).
auiToolBarFindToolByPosition :: AuiToolBar  a -> Point ->  IO (AuiToolBarItem  ())
auiToolBarFindToolByPosition _obj xy 
  = withObjectResult $
    withObjectRef "auiToolBarFindToolByPosition" _obj $ \cobj__obj -> 
    wxAuiToolBar_FindToolByPosition cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiToolBar_FindToolByPosition" wxAuiToolBar_FindToolByPosition :: Ptr (TAuiToolBar a) -> CInt -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarGetArtProvider obj@).
auiToolBarGetArtProvider :: AuiToolBar  a ->  IO (AuiToolBarArt  ())
auiToolBarGetArtProvider _obj 
  = withObjectResult $
    withObjectRef "auiToolBarGetArtProvider" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetArtProvider cobj__obj  
foreign import ccall "wxAuiToolBar_GetArtProvider" wxAuiToolBar_GetArtProvider :: Ptr (TAuiToolBar a) -> IO (Ptr (TAuiToolBarArt ()))

-- | usage: (@auiToolBarGetGripperVisible obj@).
auiToolBarGetGripperVisible :: AuiToolBar  a ->  IO Bool
auiToolBarGetGripperVisible _obj 
  = withBoolResult $
    withObjectRef "auiToolBarGetGripperVisible" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetGripperVisible cobj__obj  
foreign import ccall "wxAuiToolBar_GetGripperVisible" wxAuiToolBar_GetGripperVisible :: Ptr (TAuiToolBar a) -> IO CBool

-- | usage: (@auiToolBarGetHintSize obj dockdirection@).
auiToolBarGetHintSize :: AuiToolBar  a -> Int ->  IO (Size)
auiToolBarGetHintSize _obj dockdirection 
  = withWxSizeResult $
    withObjectRef "auiToolBarGetHintSize" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetHintSize cobj__obj  (toCInt dockdirection)  
foreign import ccall "wxAuiToolBar_GetHintSize" wxAuiToolBar_GetHintSize :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TWxSize ()))

-- | usage: (@auiToolBarGetOverflowVisible obj@).
auiToolBarGetOverflowVisible :: AuiToolBar  a ->  IO Bool
auiToolBarGetOverflowVisible _obj 
  = withBoolResult $
    withObjectRef "auiToolBarGetOverflowVisible" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetOverflowVisible cobj__obj  
foreign import ccall "wxAuiToolBar_GetOverflowVisible" wxAuiToolBar_GetOverflowVisible :: Ptr (TAuiToolBar a) -> IO CBool

-- | usage: (@auiToolBarGetToolBarFits obj@).
auiToolBarGetToolBarFits :: AuiToolBar  a ->  IO Bool
auiToolBarGetToolBarFits _obj 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolBarFits" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolBarFits cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolBarFits" wxAuiToolBar_GetToolBarFits :: Ptr (TAuiToolBar a) -> IO CBool

-- | usage: (@auiToolBarGetToolBitmap obj toolid@).
auiToolBarGetToolBitmap :: AuiToolBar  a -> Int ->  IO (Bitmap  ())
auiToolBarGetToolBitmap _obj toolid 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiToolBarGetToolBitmap" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolBitmap cobj__obj  (toCInt toolid)   pref
foreign import ccall "wxAuiToolBar_GetToolBitmap" wxAuiToolBar_GetToolBitmap :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiToolBarGetToolBitmapSize obj@).
auiToolBarGetToolBitmapSize :: AuiToolBar  a ->  IO (Size)
auiToolBarGetToolBitmapSize _obj 
  = withWxSizeResult $
    withObjectRef "auiToolBarGetToolBitmapSize" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolBitmapSize cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolBitmapSize" wxAuiToolBar_GetToolBitmapSize :: Ptr (TAuiToolBar a) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiToolBarGetToolBorderPadding obj@).
auiToolBarGetToolBorderPadding :: AuiToolBar  a ->  IO Int
auiToolBarGetToolBorderPadding _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetToolBorderPadding" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolBorderPadding cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolBorderPadding" wxAuiToolBar_GetToolBorderPadding :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarGetToolCount obj@).
auiToolBarGetToolCount :: AuiToolBar  a ->  IO Int
auiToolBarGetToolCount _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetToolCount" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolCount cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolCount" wxAuiToolBar_GetToolCount :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarGetToolDropDown obj toolid@).
auiToolBarGetToolDropDown :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolDropDown _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolDropDown" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolDropDown cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolDropDown" wxAuiToolBar_GetToolDropDown :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetToolEnabled obj toolid@).
auiToolBarGetToolEnabled :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolEnabled _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolEnabled" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolEnabled cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolEnabled" wxAuiToolBar_GetToolEnabled :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetToolFits obj toolid@).
auiToolBarGetToolFits :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolFits _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolFits" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolFits cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolFits" wxAuiToolBar_GetToolFits :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetToolFitsByIndex obj toolid@).
auiToolBarGetToolFitsByIndex :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolFitsByIndex _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolFitsByIndex" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolFitsByIndex cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolFitsByIndex" wxAuiToolBar_GetToolFitsByIndex :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetToolIndex obj toolid@).
auiToolBarGetToolIndex :: AuiToolBar  a -> Int ->  IO Int
auiToolBarGetToolIndex _obj toolid 
  = withIntResult $
    withObjectRef "auiToolBarGetToolIndex" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolIndex cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolIndex" wxAuiToolBar_GetToolIndex :: Ptr (TAuiToolBar a) -> CInt -> IO CInt

-- | usage: (@auiToolBarGetToolLabel obj toolid@).
auiToolBarGetToolLabel :: AuiToolBar  a -> Int ->  IO (String)
auiToolBarGetToolLabel _obj toolid 
  = withManagedStringResult $
    withObjectRef "auiToolBarGetToolLabel" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolLabel cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolLabel" wxAuiToolBar_GetToolLabel :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarGetToolLongHelp obj toolid@).
auiToolBarGetToolLongHelp :: AuiToolBar  a -> Int ->  IO (String)
auiToolBarGetToolLongHelp _obj toolid 
  = withManagedStringResult $
    withObjectRef "auiToolBarGetToolLongHelp" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolLongHelp cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolLongHelp" wxAuiToolBar_GetToolLongHelp :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarGetToolPacking obj@).
auiToolBarGetToolPacking :: AuiToolBar  a ->  IO Int
auiToolBarGetToolPacking _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetToolPacking" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolPacking cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolPacking" wxAuiToolBar_GetToolPacking :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarGetToolPos obj toolid@).
auiToolBarGetToolPos :: AuiToolBar  a -> Int ->  IO Int
auiToolBarGetToolPos _obj toolid 
  = withIntResult $
    withObjectRef "auiToolBarGetToolPos" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolPos cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolPos" wxAuiToolBar_GetToolPos :: Ptr (TAuiToolBar a) -> CInt -> IO CInt

-- | usage: (@auiToolBarGetToolProportion obj toolid@).
auiToolBarGetToolProportion :: AuiToolBar  a -> Int ->  IO Int
auiToolBarGetToolProportion _obj toolid 
  = withIntResult $
    withObjectRef "auiToolBarGetToolProportion" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolProportion cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolProportion" wxAuiToolBar_GetToolProportion :: Ptr (TAuiToolBar a) -> CInt -> IO CInt

-- | usage: (@auiToolBarGetToolRect obj toolid@).
auiToolBarGetToolRect :: AuiToolBar  a -> Int ->  IO (Rect)
auiToolBarGetToolRect _obj toolid 
  = withWxRectResult $
    withObjectRef "auiToolBarGetToolRect" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolRect cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolRect" wxAuiToolBar_GetToolRect :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@auiToolBarGetToolSeparation obj@).
auiToolBarGetToolSeparation :: AuiToolBar  a ->  IO Int
auiToolBarGetToolSeparation _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetToolSeparation" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolSeparation cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolSeparation" wxAuiToolBar_GetToolSeparation :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarGetToolShortHelp obj toolid@).
auiToolBarGetToolShortHelp :: AuiToolBar  a -> Int ->  IO (String)
auiToolBarGetToolShortHelp _obj toolid 
  = withManagedStringResult $
    withObjectRef "auiToolBarGetToolShortHelp" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolShortHelp cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolShortHelp" wxAuiToolBar_GetToolShortHelp :: Ptr (TAuiToolBar a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarGetToolSticky obj toolid@).
auiToolBarGetToolSticky :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolSticky _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolSticky" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolSticky cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolSticky" wxAuiToolBar_GetToolSticky :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetToolTextOrientation obj@).
auiToolBarGetToolTextOrientation :: AuiToolBar  a ->  IO Int
auiToolBarGetToolTextOrientation _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetToolTextOrientation" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolTextOrientation cobj__obj  
foreign import ccall "wxAuiToolBar_GetToolTextOrientation" wxAuiToolBar_GetToolTextOrientation :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarGetToolToggled obj toolid@).
auiToolBarGetToolToggled :: AuiToolBar  a -> Int ->  IO Bool
auiToolBarGetToolToggled _obj toolid 
  = withBoolResult $
    withObjectRef "auiToolBarGetToolToggled" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetToolToggled cobj__obj  (toCInt toolid)  
foreign import ccall "wxAuiToolBar_GetToolToggled" wxAuiToolBar_GetToolToggled :: Ptr (TAuiToolBar a) -> CInt -> IO CBool

-- | usage: (@auiToolBarGetWindowStyleFlag obj@).
auiToolBarGetWindowStyleFlag :: AuiToolBar  a ->  IO Int
auiToolBarGetWindowStyleFlag _obj 
  = withIntResult $
    withObjectRef "auiToolBarGetWindowStyleFlag" _obj $ \cobj__obj -> 
    wxAuiToolBar_GetWindowStyleFlag cobj__obj  
foreign import ccall "wxAuiToolBar_GetWindowStyleFlag" wxAuiToolBar_GetWindowStyleFlag :: Ptr (TAuiToolBar a) -> IO CInt

-- | usage: (@auiToolBarIsPaneValid obj pane@).
auiToolBarIsPaneValid :: AuiToolBar  a -> AuiPaneInfo  b ->  IO Bool
auiToolBarIsPaneValid _obj _pane 
  = withBoolResult $
    withObjectRef "auiToolBarIsPaneValid" _obj $ \cobj__obj -> 
    withObjectPtr _pane $ \cobj__pane -> 
    wxAuiToolBar_IsPaneValid cobj__obj  cobj__pane  
foreign import ccall "wxAuiToolBar_IsPaneValid" wxAuiToolBar_IsPaneValid :: Ptr (TAuiToolBar a) -> Ptr (TAuiPaneInfo b) -> IO CBool

-- | usage: (@auiToolBarItemArrayCreate@).
auiToolBarItemArrayCreate ::  IO (AuiToolBarItemArray  ())
auiToolBarItemArrayCreate 
  = withObjectResult $
    wxAuiToolBarItemArray_Create 
foreign import ccall "wxAuiToolBarItemArray_Create" wxAuiToolBarItemArray_Create :: IO (Ptr (TAuiToolBarItemArray ()))

-- | usage: (@auiToolBarItemArrayDelete obj@).
auiToolBarItemArrayDelete :: AuiToolBarItemArray  a ->  IO ()
auiToolBarItemArrayDelete _obj 
  = withObjectRef "auiToolBarItemArrayDelete" _obj $ \cobj__obj -> 
    wxAuiToolBarItemArray_Delete cobj__obj  
foreign import ccall "wxAuiToolBarItemArray_Delete" wxAuiToolBarItemArray_Delete :: Ptr (TAuiToolBarItemArray a) -> IO ()

-- | usage: (@auiToolBarItemArrayGetCount obj@).
auiToolBarItemArrayGetCount :: AuiToolBarItemArray  a ->  IO Int
auiToolBarItemArrayGetCount _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemArrayGetCount" _obj $ \cobj__obj -> 
    wxAuiToolBarItemArray_GetCount cobj__obj  
foreign import ccall "wxAuiToolBarItemArray_GetCount" wxAuiToolBarItemArray_GetCount :: Ptr (TAuiToolBarItemArray a) -> IO CInt

-- | usage: (@auiToolBarItemArrayItem obj idx@).
auiToolBarItemArrayItem :: AuiToolBarItemArray  a -> Int ->  IO (AuiToolBarItem  ())
auiToolBarItemArrayItem _obj _idx 
  = withObjectResult $
    withObjectRef "auiToolBarItemArrayItem" _obj $ \cobj__obj -> 
    wxAuiToolBarItemArray_Item cobj__obj  (toCInt _idx)  
foreign import ccall "wxAuiToolBarItemArray_Item" wxAuiToolBarItemArray_Item :: Ptr (TAuiToolBarItemArray a) -> CInt -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarItemAssign obj c@).
auiToolBarItemAssign :: AuiToolBarItem  a -> AuiToolBarItem  b ->  IO ()
auiToolBarItemAssign _obj _c 
  = withObjectRef "auiToolBarItemAssign" _obj $ \cobj__obj -> 
    withObjectPtr _c $ \cobj__c -> 
    wxAuiToolBarItem_Assign cobj__obj  cobj__c  
foreign import ccall "wxAuiToolBarItem_Assign" wxAuiToolBarItem_Assign :: Ptr (TAuiToolBarItem a) -> Ptr (TAuiToolBarItem b) -> IO ()

-- | usage: (@auiToolBarItemCopy obj c@).
auiToolBarItemCopy :: AuiToolBarItem  a -> AuiToolBarItem  b ->  IO (AuiToolBarItem  ())
auiToolBarItemCopy _obj _c 
  = withObjectResult $
    withObjectRef "auiToolBarItemCopy" _obj $ \cobj__obj -> 
    withObjectPtr _c $ \cobj__c -> 
    wxAuiToolBarItem_Copy cobj__obj  cobj__c  
foreign import ccall "wxAuiToolBarItem_Copy" wxAuiToolBarItem_Copy :: Ptr (TAuiToolBarItem a) -> Ptr (TAuiToolBarItem b) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarItemCreate c@).
auiToolBarItemCreate :: AuiToolBarItem  a ->  IO (AuiToolBarItem  ())
auiToolBarItemCreate _c 
  = withObjectResult $
    withObjectPtr _c $ \cobj__c -> 
    wxAuiToolBarItem_Create cobj__c  
foreign import ccall "wxAuiToolBarItem_Create" wxAuiToolBarItem_Create :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarItemCreateDefault@).
auiToolBarItemCreateDefault ::  IO (AuiToolBarItem  ())
auiToolBarItemCreateDefault 
  = withObjectResult $
    wxAuiToolBarItem_CreateDefault 
foreign import ccall "wxAuiToolBarItem_CreateDefault" wxAuiToolBarItem_CreateDefault :: IO (Ptr (TAuiToolBarItem ()))

-- | usage: (@auiToolBarItemGetAlignment obj@).
auiToolBarItemGetAlignment :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetAlignment _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetAlignment" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetAlignment cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetAlignment" wxAuiToolBarItem_GetAlignment :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetBitmap obj@).
auiToolBarItemGetBitmap :: AuiToolBarItem  a ->  IO (Bitmap  ())
auiToolBarItemGetBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiToolBarItemGetBitmap" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetBitmap cobj__obj   pref
foreign import ccall "wxAuiToolBarItem_GetBitmap" wxAuiToolBarItem_GetBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiToolBarItemGetDisabledBitmap obj@).
auiToolBarItemGetDisabledBitmap :: AuiToolBarItem  a ->  IO (Bitmap  ())
auiToolBarItemGetDisabledBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiToolBarItemGetDisabledBitmap" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetDisabledBitmap cobj__obj   pref
foreign import ccall "wxAuiToolBarItem_GetDisabledBitmap" wxAuiToolBarItem_GetDisabledBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiToolBarItemGetHoverBitmap obj@).
auiToolBarItemGetHoverBitmap :: AuiToolBarItem  a ->  IO (Bitmap  ())
auiToolBarItemGetHoverBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "auiToolBarItemGetHoverBitmap" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetHoverBitmap cobj__obj   pref
foreign import ccall "wxAuiToolBarItem_GetHoverBitmap" wxAuiToolBarItem_GetHoverBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@auiToolBarItemGetId obj@).
auiToolBarItemGetId :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetId _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetId" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetId cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetId" wxAuiToolBarItem_GetId :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetKind obj@).
auiToolBarItemGetKind :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetKind _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetKind" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetKind cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetKind" wxAuiToolBarItem_GetKind :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetLabel obj@).
auiToolBarItemGetLabel :: AuiToolBarItem  a ->  IO (String)
auiToolBarItemGetLabel _obj 
  = withManagedStringResult $
    withObjectRef "auiToolBarItemGetLabel" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetLabel cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetLabel" wxAuiToolBarItem_GetLabel :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarItemGetLongHelp obj@).
auiToolBarItemGetLongHelp :: AuiToolBarItem  a ->  IO (String)
auiToolBarItemGetLongHelp _obj 
  = withManagedStringResult $
    withObjectRef "auiToolBarItemGetLongHelp" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetLongHelp cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetLongHelp" wxAuiToolBarItem_GetLongHelp :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarItemGetMinSize obj@).
auiToolBarItemGetMinSize :: AuiToolBarItem  a ->  IO (Size)
auiToolBarItemGetMinSize _obj 
  = withWxSizeResult $
    withObjectRef "auiToolBarItemGetMinSize" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetMinSize cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetMinSize" wxAuiToolBarItem_GetMinSize :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TWxSize ()))

-- | usage: (@auiToolBarItemGetProportion obj@).
auiToolBarItemGetProportion :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetProportion _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetProportion" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetProportion cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetProportion" wxAuiToolBarItem_GetProportion :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetShortHelp obj@).
auiToolBarItemGetShortHelp :: AuiToolBarItem  a ->  IO (String)
auiToolBarItemGetShortHelp _obj 
  = withManagedStringResult $
    withObjectRef "auiToolBarItemGetShortHelp" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetShortHelp cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetShortHelp" wxAuiToolBarItem_GetShortHelp :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TWxString ()))

-- | usage: (@auiToolBarItemGetSizerItem obj@).
auiToolBarItemGetSizerItem :: AuiToolBarItem  a ->  IO (SizerItem  ())
auiToolBarItemGetSizerItem _obj 
  = withObjectResult $
    withObjectRef "auiToolBarItemGetSizerItem" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetSizerItem cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetSizerItem" wxAuiToolBarItem_GetSizerItem :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TSizerItem ()))

-- | usage: (@auiToolBarItemGetSpacerPixels obj@).
auiToolBarItemGetSpacerPixels :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetSpacerPixels _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetSpacerPixels" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetSpacerPixels cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetSpacerPixels" wxAuiToolBarItem_GetSpacerPixels :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetState obj@).
auiToolBarItemGetState :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetState _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetState" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetState cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetState" wxAuiToolBarItem_GetState :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetUserData obj@).
auiToolBarItemGetUserData :: AuiToolBarItem  a ->  IO Int
auiToolBarItemGetUserData _obj 
  = withIntResult $
    withObjectRef "auiToolBarItemGetUserData" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetUserData cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetUserData" wxAuiToolBarItem_GetUserData :: Ptr (TAuiToolBarItem a) -> IO CInt

-- | usage: (@auiToolBarItemGetWindow obj@).
auiToolBarItemGetWindow :: AuiToolBarItem  a ->  IO (Window  ())
auiToolBarItemGetWindow _obj 
  = withObjectResult $
    withObjectRef "auiToolBarItemGetWindow" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_GetWindow cobj__obj  
foreign import ccall "wxAuiToolBarItem_GetWindow" wxAuiToolBarItem_GetWindow :: Ptr (TAuiToolBarItem a) -> IO (Ptr (TWindow ()))

-- | usage: (@auiToolBarItemHasDropDown obj@).
auiToolBarItemHasDropDown :: AuiToolBarItem  a ->  IO Bool
auiToolBarItemHasDropDown _obj 
  = withBoolResult $
    withObjectRef "auiToolBarItemHasDropDown" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_HasDropDown cobj__obj  
foreign import ccall "wxAuiToolBarItem_HasDropDown" wxAuiToolBarItem_HasDropDown :: Ptr (TAuiToolBarItem a) -> IO CBool

-- | usage: (@auiToolBarItemIsActive obj@).
auiToolBarItemIsActive :: AuiToolBarItem  a ->  IO Bool
auiToolBarItemIsActive _obj 
  = withBoolResult $
    withObjectRef "auiToolBarItemIsActive" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_IsActive cobj__obj  
foreign import ccall "wxAuiToolBarItem_IsActive" wxAuiToolBarItem_IsActive :: Ptr (TAuiToolBarItem a) -> IO CBool

-- | usage: (@auiToolBarItemIsSticky obj@).
auiToolBarItemIsSticky :: AuiToolBarItem  a ->  IO Bool
auiToolBarItemIsSticky _obj 
  = withBoolResult $
    withObjectRef "auiToolBarItemIsSticky" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_IsSticky cobj__obj  
foreign import ccall "wxAuiToolBarItem_IsSticky" wxAuiToolBarItem_IsSticky :: Ptr (TAuiToolBarItem a) -> IO CBool

-- | usage: (@auiToolBarItemSetActive obj b@).
auiToolBarItemSetActive :: AuiToolBarItem  a -> Bool ->  IO ()
auiToolBarItemSetActive _obj b 
  = withObjectRef "auiToolBarItemSetActive" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetActive cobj__obj  (toCBool b)  
foreign import ccall "wxAuiToolBarItem_SetActive" wxAuiToolBarItem_SetActive :: Ptr (TAuiToolBarItem a) -> CBool -> IO ()

-- | usage: (@auiToolBarItemSetAlignment obj l@).
auiToolBarItemSetAlignment :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetAlignment _obj l 
  = withObjectRef "auiToolBarItemSetAlignment" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetAlignment cobj__obj  (toCInt l)  
foreign import ccall "wxAuiToolBarItem_SetAlignment" wxAuiToolBarItem_SetAlignment :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetBitmap obj bmp@).
auiToolBarItemSetBitmap :: AuiToolBarItem  a -> Bitmap  b ->  IO ()
auiToolBarItemSetBitmap _obj _bmp 
  = withObjectRef "auiToolBarItemSetBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxAuiToolBarItem_SetBitmap cobj__obj  cobj__bmp  
foreign import ccall "wxAuiToolBarItem_SetBitmap" wxAuiToolBarItem_SetBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@auiToolBarItemSetDisabledBitmap obj bmp@).
auiToolBarItemSetDisabledBitmap :: AuiToolBarItem  a -> Bitmap  b ->  IO ()
auiToolBarItemSetDisabledBitmap _obj _bmp 
  = withObjectRef "auiToolBarItemSetDisabledBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxAuiToolBarItem_SetDisabledBitmap cobj__obj  cobj__bmp  
foreign import ccall "wxAuiToolBarItem_SetDisabledBitmap" wxAuiToolBarItem_SetDisabledBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@auiToolBarItemSetHasDropDown obj b@).
auiToolBarItemSetHasDropDown :: AuiToolBarItem  a -> Bool ->  IO ()
auiToolBarItemSetHasDropDown _obj b 
  = withObjectRef "auiToolBarItemSetHasDropDown" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetHasDropDown cobj__obj  (toCBool b)  
foreign import ccall "wxAuiToolBarItem_SetHasDropDown" wxAuiToolBarItem_SetHasDropDown :: Ptr (TAuiToolBarItem a) -> CBool -> IO ()

-- | usage: (@auiToolBarItemSetHoverBitmap obj bmp@).
auiToolBarItemSetHoverBitmap :: AuiToolBarItem  a -> Bitmap  b ->  IO ()
auiToolBarItemSetHoverBitmap _obj _bmp 
  = withObjectRef "auiToolBarItemSetHoverBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxAuiToolBarItem_SetHoverBitmap cobj__obj  cobj__bmp  
foreign import ccall "wxAuiToolBarItem_SetHoverBitmap" wxAuiToolBarItem_SetHoverBitmap :: Ptr (TAuiToolBarItem a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@auiToolBarItemSetId obj newid@).
auiToolBarItemSetId :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetId _obj newid 
  = withObjectRef "auiToolBarItemSetId" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetId cobj__obj  (toCInt newid)  
foreign import ccall "wxAuiToolBarItem_SetId" wxAuiToolBarItem_SetId :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetKind obj newkind@).
auiToolBarItemSetKind :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetKind _obj newkind 
  = withObjectRef "auiToolBarItemSetKind" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetKind cobj__obj  (toCInt newkind)  
foreign import ccall "wxAuiToolBarItem_SetKind" wxAuiToolBarItem_SetKind :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetLabel obj s@).
auiToolBarItemSetLabel :: AuiToolBarItem  a -> String ->  IO ()
auiToolBarItemSetLabel _obj _s 
  = withObjectRef "auiToolBarItemSetLabel" _obj $ \cobj__obj -> 
    withStringPtr _s $ \cobj__s -> 
    wxAuiToolBarItem_SetLabel cobj__obj  cobj__s  
foreign import ccall "wxAuiToolBarItem_SetLabel" wxAuiToolBarItem_SetLabel :: Ptr (TAuiToolBarItem a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@auiToolBarItemSetLongHelp obj s@).
auiToolBarItemSetLongHelp :: AuiToolBarItem  a -> String ->  IO ()
auiToolBarItemSetLongHelp _obj _s 
  = withObjectRef "auiToolBarItemSetLongHelp" _obj $ \cobj__obj -> 
    withStringPtr _s $ \cobj__s -> 
    wxAuiToolBarItem_SetLongHelp cobj__obj  cobj__s  
foreign import ccall "wxAuiToolBarItem_SetLongHelp" wxAuiToolBarItem_SetLongHelp :: Ptr (TAuiToolBarItem a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@auiToolBarItemSetMinSize obj widthheight@).
auiToolBarItemSetMinSize :: AuiToolBarItem  a -> Size ->  IO ()
auiToolBarItemSetMinSize _obj _widthheight 
  = withObjectRef "auiToolBarItemSetMinSize" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetMinSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiToolBarItem_SetMinSize" wxAuiToolBarItem_SetMinSize :: Ptr (TAuiToolBarItem a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetProportion obj p@).
auiToolBarItemSetProportion :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetProportion _obj p 
  = withObjectRef "auiToolBarItemSetProportion" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetProportion cobj__obj  (toCInt p)  
foreign import ccall "wxAuiToolBarItem_SetProportion" wxAuiToolBarItem_SetProportion :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetShortHelp obj s@).
auiToolBarItemSetShortHelp :: AuiToolBarItem  a -> String ->  IO ()
auiToolBarItemSetShortHelp _obj _s 
  = withObjectRef "auiToolBarItemSetShortHelp" _obj $ \cobj__obj -> 
    withStringPtr _s $ \cobj__s -> 
    wxAuiToolBarItem_SetShortHelp cobj__obj  cobj__s  
foreign import ccall "wxAuiToolBarItem_SetShortHelp" wxAuiToolBarItem_SetShortHelp :: Ptr (TAuiToolBarItem a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@auiToolBarItemSetSizerItem obj s@).
auiToolBarItemSetSizerItem :: AuiToolBarItem  a -> SizerItem  b ->  IO ()
auiToolBarItemSetSizerItem _obj _s 
  = withObjectRef "auiToolBarItemSetSizerItem" _obj $ \cobj__obj -> 
    withObjectPtr _s $ \cobj__s -> 
    wxAuiToolBarItem_SetSizerItem cobj__obj  cobj__s  
foreign import ccall "wxAuiToolBarItem_SetSizerItem" wxAuiToolBarItem_SetSizerItem :: Ptr (TAuiToolBarItem a) -> Ptr (TSizerItem b) -> IO ()

-- | usage: (@auiToolBarItemSetSpacerPixels obj s@).
auiToolBarItemSetSpacerPixels :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetSpacerPixels _obj s 
  = withObjectRef "auiToolBarItemSetSpacerPixels" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetSpacerPixels cobj__obj  (toCInt s)  
foreign import ccall "wxAuiToolBarItem_SetSpacerPixels" wxAuiToolBarItem_SetSpacerPixels :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetState obj newstate@).
auiToolBarItemSetState :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetState _obj newstate 
  = withObjectRef "auiToolBarItemSetState" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetState cobj__obj  (toCInt newstate)  
foreign import ccall "wxAuiToolBarItem_SetState" wxAuiToolBarItem_SetState :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetSticky obj b@).
auiToolBarItemSetSticky :: AuiToolBarItem  a -> Bool ->  IO ()
auiToolBarItemSetSticky _obj b 
  = withObjectRef "auiToolBarItemSetSticky" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetSticky cobj__obj  (toCBool b)  
foreign import ccall "wxAuiToolBarItem_SetSticky" wxAuiToolBarItem_SetSticky :: Ptr (TAuiToolBarItem a) -> CBool -> IO ()

-- | usage: (@auiToolBarItemSetUserData obj l@).
auiToolBarItemSetUserData :: AuiToolBarItem  a -> Int ->  IO ()
auiToolBarItemSetUserData _obj l 
  = withObjectRef "auiToolBarItemSetUserData" _obj $ \cobj__obj -> 
    wxAuiToolBarItem_SetUserData cobj__obj  (toCInt l)  
foreign import ccall "wxAuiToolBarItem_SetUserData" wxAuiToolBarItem_SetUserData :: Ptr (TAuiToolBarItem a) -> CInt -> IO ()

-- | usage: (@auiToolBarItemSetWindow obj w@).
auiToolBarItemSetWindow :: AuiToolBarItem  a -> Window  b ->  IO ()
auiToolBarItemSetWindow _obj _w 
  = withObjectRef "auiToolBarItemSetWindow" _obj $ \cobj__obj -> 
    withObjectPtr _w $ \cobj__w -> 
    wxAuiToolBarItem_SetWindow cobj__obj  cobj__w  
foreign import ccall "wxAuiToolBarItem_SetWindow" wxAuiToolBarItem_SetWindow :: Ptr (TAuiToolBarItem a) -> Ptr (TWindow b) -> IO ()

-- | usage: (@auiToolBarRealize obj@).
auiToolBarRealize :: AuiToolBar  a ->  IO Bool
auiToolBarRealize _obj 
  = withBoolResult $
    withObjectRef "auiToolBarRealize" _obj $ \cobj__obj -> 
    wxAuiToolBar_Realize cobj__obj  
foreign import ccall "wxAuiToolBar_Realize" wxAuiToolBar_Realize :: Ptr (TAuiToolBar a) -> IO CBool

-- | usage: (@auiToolBarSetArtProvider obj art@).
auiToolBarSetArtProvider :: AuiToolBar  a -> AuiToolBarArt  b ->  IO ()
auiToolBarSetArtProvider _obj _art 
  = withObjectRef "auiToolBarSetArtProvider" _obj $ \cobj__obj -> 
    withObjectPtr _art $ \cobj__art -> 
    wxAuiToolBar_SetArtProvider cobj__obj  cobj__art  
foreign import ccall "wxAuiToolBar_SetArtProvider" wxAuiToolBar_SetArtProvider :: Ptr (TAuiToolBar a) -> Ptr (TAuiToolBarArt b) -> IO ()

-- | usage: (@auiToolBarSetCustomOverflowItems obj prepend append@).
auiToolBarSetCustomOverflowItems :: AuiToolBar  a -> AuiToolBarItemArray  b -> AuiToolBarItemArray  c ->  IO ()
auiToolBarSetCustomOverflowItems _obj _prepend _append 
  = withObjectRef "auiToolBarSetCustomOverflowItems" _obj $ \cobj__obj -> 
    withObjectPtr _prepend $ \cobj__prepend -> 
    withObjectPtr _append $ \cobj__append -> 
    wxAuiToolBar_SetCustomOverflowItems cobj__obj  cobj__prepend  cobj__append  
foreign import ccall "wxAuiToolBar_SetCustomOverflowItems" wxAuiToolBar_SetCustomOverflowItems :: Ptr (TAuiToolBar a) -> Ptr (TAuiToolBarItemArray b) -> Ptr (TAuiToolBarItemArray c) -> IO ()

-- | usage: (@auiToolBarSetFont obj font@).
auiToolBarSetFont :: AuiToolBar  a -> Font  b ->  IO Bool
auiToolBarSetFont _obj _font 
  = withBoolResult $
    withObjectRef "auiToolBarSetFont" _obj $ \cobj__obj -> 
    withObjectPtr _font $ \cobj__font -> 
    wxAuiToolBar_SetFont cobj__obj  cobj__font  
foreign import ccall "wxAuiToolBar_SetFont" wxAuiToolBar_SetFont :: Ptr (TAuiToolBar a) -> Ptr (TFont b) -> IO CBool

-- | usage: (@auiToolBarSetGripperVisible obj visible@).
auiToolBarSetGripperVisible :: AuiToolBar  a -> Bool ->  IO ()
auiToolBarSetGripperVisible _obj visible 
  = withObjectRef "auiToolBarSetGripperVisible" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetGripperVisible cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiToolBar_SetGripperVisible" wxAuiToolBar_SetGripperVisible :: Ptr (TAuiToolBar a) -> CBool -> IO ()

-- | usage: (@auiToolBarSetMargins obj widthheight@).
auiToolBarSetMargins :: AuiToolBar  a -> Size ->  IO ()
auiToolBarSetMargins _obj _widthheight 
  = withObjectRef "auiToolBarSetMargins" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetMargins cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiToolBar_SetMargins" wxAuiToolBar_SetMargins :: Ptr (TAuiToolBar a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarSetMarginsDetailed obj left right top bottom@).
auiToolBarSetMarginsDetailed :: AuiToolBar  a -> Int -> Int -> Int -> Int ->  IO ()
auiToolBarSetMarginsDetailed _obj left right top bottom 
  = withObjectRef "auiToolBarSetMarginsDetailed" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetMarginsDetailed cobj__obj  (toCInt left)  (toCInt right)  (toCInt top)  (toCInt bottom)  
foreign import ccall "wxAuiToolBar_SetMarginsDetailed" wxAuiToolBar_SetMarginsDetailed :: Ptr (TAuiToolBar a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarSetMarginsXY obj xy@).
auiToolBarSetMarginsXY :: AuiToolBar  a -> Point ->  IO ()
auiToolBarSetMarginsXY _obj xy 
  = withObjectRef "auiToolBarSetMarginsXY" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetMarginsXY cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxAuiToolBar_SetMarginsXY" wxAuiToolBar_SetMarginsXY :: Ptr (TAuiToolBar a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarSetOverflowVisible obj visible@).
auiToolBarSetOverflowVisible :: AuiToolBar  a -> Bool ->  IO ()
auiToolBarSetOverflowVisible _obj visible 
  = withObjectRef "auiToolBarSetOverflowVisible" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetOverflowVisible cobj__obj  (toCBool visible)  
foreign import ccall "wxAuiToolBar_SetOverflowVisible" wxAuiToolBar_SetOverflowVisible :: Ptr (TAuiToolBar a) -> CBool -> IO ()

-- | usage: (@auiToolBarSetToolBitmap obj toolid bitmap@).
auiToolBarSetToolBitmap :: AuiToolBar  a -> Int -> Bitmap  c ->  IO ()
auiToolBarSetToolBitmap _obj toolid _bitmap 
  = withObjectRef "auiToolBarSetToolBitmap" _obj $ \cobj__obj -> 
    withObjectPtr _bitmap $ \cobj__bitmap -> 
    wxAuiToolBar_SetToolBitmap cobj__obj  (toCInt toolid)  cobj__bitmap  
foreign import ccall "wxAuiToolBar_SetToolBitmap" wxAuiToolBar_SetToolBitmap :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TBitmap c) -> IO ()

-- | usage: (@auiToolBarSetToolBitmapSize obj widthheight@).
auiToolBarSetToolBitmapSize :: AuiToolBar  a -> Size ->  IO ()
auiToolBarSetToolBitmapSize _obj _widthheight 
  = withObjectRef "auiToolBarSetToolBitmapSize" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolBitmapSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxAuiToolBar_SetToolBitmapSize" wxAuiToolBar_SetToolBitmapSize :: Ptr (TAuiToolBar a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarSetToolBorderPadding obj padding@).
auiToolBarSetToolBorderPadding :: AuiToolBar  a -> Int ->  IO ()
auiToolBarSetToolBorderPadding _obj padding 
  = withObjectRef "auiToolBarSetToolBorderPadding" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolBorderPadding cobj__obj  (toCInt padding)  
foreign import ccall "wxAuiToolBar_SetToolBorderPadding" wxAuiToolBar_SetToolBorderPadding :: Ptr (TAuiToolBar a) -> CInt -> IO ()

-- | usage: (@auiToolBarSetToolDropDown obj toolid dropdown@).
auiToolBarSetToolDropDown :: AuiToolBar  a -> Int -> Bool ->  IO ()
auiToolBarSetToolDropDown _obj toolid dropdown 
  = withObjectRef "auiToolBarSetToolDropDown" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolDropDown cobj__obj  (toCInt toolid)  (toCBool dropdown)  
foreign import ccall "wxAuiToolBar_SetToolDropDown" wxAuiToolBar_SetToolDropDown :: Ptr (TAuiToolBar a) -> CInt -> CBool -> IO ()

-- | usage: (@auiToolBarSetToolLabel obj toolid label@).
auiToolBarSetToolLabel :: AuiToolBar  a -> Int -> String ->  IO ()
auiToolBarSetToolLabel _obj toolid _label 
  = withObjectRef "auiToolBarSetToolLabel" _obj $ \cobj__obj -> 
    withStringPtr _label $ \cobj__label -> 
    wxAuiToolBar_SetToolLabel cobj__obj  (toCInt toolid)  cobj__label  
foreign import ccall "wxAuiToolBar_SetToolLabel" wxAuiToolBar_SetToolLabel :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@auiToolBarSetToolLongHelp obj toolid helpstring@).
auiToolBarSetToolLongHelp :: AuiToolBar  a -> Int -> String ->  IO ()
auiToolBarSetToolLongHelp _obj toolid _helpstring 
  = withObjectRef "auiToolBarSetToolLongHelp" _obj $ \cobj__obj -> 
    withStringPtr _helpstring $ \cobj__helpstring -> 
    wxAuiToolBar_SetToolLongHelp cobj__obj  (toCInt toolid)  cobj__helpstring  
foreign import ccall "wxAuiToolBar_SetToolLongHelp" wxAuiToolBar_SetToolLongHelp :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@auiToolBarSetToolPacking obj packing@).
auiToolBarSetToolPacking :: AuiToolBar  a -> Int ->  IO ()
auiToolBarSetToolPacking _obj packing 
  = withObjectRef "auiToolBarSetToolPacking" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolPacking cobj__obj  (toCInt packing)  
foreign import ccall "wxAuiToolBar_SetToolPacking" wxAuiToolBar_SetToolPacking :: Ptr (TAuiToolBar a) -> CInt -> IO ()

-- | usage: (@auiToolBarSetToolProportion obj toolid proportion@).
auiToolBarSetToolProportion :: AuiToolBar  a -> Int -> Int ->  IO ()
auiToolBarSetToolProportion _obj toolid proportion 
  = withObjectRef "auiToolBarSetToolProportion" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolProportion cobj__obj  (toCInt toolid)  (toCInt proportion)  
foreign import ccall "wxAuiToolBar_SetToolProportion" wxAuiToolBar_SetToolProportion :: Ptr (TAuiToolBar a) -> CInt -> CInt -> IO ()

-- | usage: (@auiToolBarSetToolSeparation obj separation@).
auiToolBarSetToolSeparation :: AuiToolBar  a -> Int ->  IO ()
auiToolBarSetToolSeparation _obj separation 
  = withObjectRef "auiToolBarSetToolSeparation" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolSeparation cobj__obj  (toCInt separation)  
foreign import ccall "wxAuiToolBar_SetToolSeparation" wxAuiToolBar_SetToolSeparation :: Ptr (TAuiToolBar a) -> CInt -> IO ()

-- | usage: (@auiToolBarSetToolShortHelp obj toolid helpstring@).
auiToolBarSetToolShortHelp :: AuiToolBar  a -> Int -> String ->  IO ()
auiToolBarSetToolShortHelp _obj toolid _helpstring 
  = withObjectRef "auiToolBarSetToolShortHelp" _obj $ \cobj__obj -> 
    withStringPtr _helpstring $ \cobj__helpstring -> 
    wxAuiToolBar_SetToolShortHelp cobj__obj  (toCInt toolid)  cobj__helpstring  
foreign import ccall "wxAuiToolBar_SetToolShortHelp" wxAuiToolBar_SetToolShortHelp :: Ptr (TAuiToolBar a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@auiToolBarSetToolSticky obj toolid sticky@).
auiToolBarSetToolSticky :: AuiToolBar  a -> Int -> Bool ->  IO ()
auiToolBarSetToolSticky _obj toolid sticky 
  = withObjectRef "auiToolBarSetToolSticky" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolSticky cobj__obj  (toCInt toolid)  (toCBool sticky)  
foreign import ccall "wxAuiToolBar_SetToolSticky" wxAuiToolBar_SetToolSticky :: Ptr (TAuiToolBar a) -> CInt -> CBool -> IO ()

-- | usage: (@auiToolBarSetToolTextOrientation obj orientation@).
auiToolBarSetToolTextOrientation :: AuiToolBar  a -> Int ->  IO ()
auiToolBarSetToolTextOrientation _obj orientation 
  = withObjectRef "auiToolBarSetToolTextOrientation" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetToolTextOrientation cobj__obj  (toCInt orientation)  
foreign import ccall "wxAuiToolBar_SetToolTextOrientation" wxAuiToolBar_SetToolTextOrientation :: Ptr (TAuiToolBar a) -> CInt -> IO ()

-- | usage: (@auiToolBarSetWindowStyleFlag obj style@).
auiToolBarSetWindowStyleFlag :: AuiToolBar  a -> Int ->  IO ()
auiToolBarSetWindowStyleFlag _obj style 
  = withObjectRef "auiToolBarSetWindowStyleFlag" _obj $ \cobj__obj -> 
    wxAuiToolBar_SetWindowStyleFlag cobj__obj  (toCInt style)  
foreign import ccall "wxAuiToolBar_SetWindowStyleFlag" wxAuiToolBar_SetWindowStyleFlag :: Ptr (TAuiToolBar a) -> CInt -> IO ()

-- | usage: (@auiToolBarToggleTool obj toolid state@).
auiToolBarToggleTool :: AuiToolBar  a -> Int -> Bool ->  IO ()
auiToolBarToggleTool _obj toolid state 
  = withObjectRef "auiToolBarToggleTool" _obj $ \cobj__obj -> 
    wxAuiToolBar_ToggleTool cobj__obj  (toCInt toolid)  (toCBool state)  
foreign import ccall "wxAuiToolBar_ToggleTool" wxAuiToolBar_ToggleTool :: Ptr (TAuiToolBar a) -> CInt -> CBool -> IO ()

-- | 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: (@bitmapToggleButtonCreate parent id bmp xywh style@).
bitmapToggleButtonCreate :: Window  a -> Id -> Bitmap  c -> Rect -> Int ->  IO (BitmapToggleButton  ())
bitmapToggleButtonCreate parent id _bmp xywh style 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxBitmapToggleButton_Create cobj_parent  (toCInt id)  cobj__bmp  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt style)  
foreign import ccall "wxBitmapToggleButton_Create" wxBitmapToggleButton_Create :: Ptr (TWindow a) -> CInt -> Ptr (TBitmap c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TBitmapToggleButton ()))

-- | usage: (@bitmapToggleButtonEnable obj enable@).
bitmapToggleButtonEnable :: BitmapToggleButton  a -> Bool ->  IO Bool
bitmapToggleButtonEnable _obj enable 
  = withBoolResult $
    withObjectRef "bitmapToggleButtonEnable" _obj $ \cobj__obj -> 
    wxBitmapToggleButton_Enable cobj__obj  (toCBool enable)  
foreign import ccall "wxBitmapToggleButton_Enable" wxBitmapToggleButton_Enable :: Ptr (TBitmapToggleButton a) -> CBool -> IO CBool

-- | usage: (@bitmapToggleButtonGetValue obj@).
bitmapToggleButtonGetValue :: BitmapToggleButton  a ->  IO Bool
bitmapToggleButtonGetValue _obj 
  = withBoolResult $
    withObjectRef "bitmapToggleButtonGetValue" _obj $ \cobj__obj -> 
    wxBitmapToggleButton_GetValue cobj__obj  
foreign import ccall "wxBitmapToggleButton_GetValue" wxBitmapToggleButton_GetValue :: Ptr (TBitmapToggleButton a) -> IO CBool

-- | usage: (@bitmapToggleButtonSetBitmapLabel obj bmp@).
bitmapToggleButtonSetBitmapLabel :: BitmapToggleButton  a -> Bitmap  b ->  IO ()
bitmapToggleButtonSetBitmapLabel _obj _bmp 
  = withObjectRef "bitmapToggleButtonSetBitmapLabel" _obj $ \cobj__obj -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxBitmapToggleButton_SetBitmapLabel cobj__obj  cobj__bmp  
foreign import ccall "wxBitmapToggleButton_SetBitmapLabel" wxBitmapToggleButton_SetBitmapLabel :: Ptr (TBitmapToggleButton a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapToggleButtonSetValue obj state@).
bitmapToggleButtonSetValue :: BitmapToggleButton  a -> Bool ->  IO ()
bitmapToggleButtonSetValue _obj state 
  = withObjectRef "bitmapToggleButtonSetValue" _obj $ \cobj__obj -> 
    wxBitmapToggleButton_SetValue cobj__obj  (toCBool state)  
foreign import ccall "wxBitmapToggleButton_SetValue" wxBitmapToggleButton_SetValue :: Ptr (TBitmapToggleButton a) -> CBool -> IO ()

-- | usage: (@bookCtrlBaseAddPage obj page text select imageId@).
bookCtrlBaseAddPage :: BookCtrlBase  a -> Window  b -> String -> Bool -> Int ->  IO Bool
bookCtrlBaseAddPage _obj _page _text select imageId 
  = withBoolResult $
    withObjectRef "bookCtrlBaseAddPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _text $ \cobj__text -> 
    wxBookCtrlBase_AddPage cobj__obj  cobj__page  cobj__text  (toCBool select)  (toCInt imageId)  
foreign import ccall "wxBookCtrlBase_AddPage" wxBookCtrlBase_AddPage :: Ptr (TBookCtrlBase a) -> Ptr (TWindow b) -> Ptr (TWxString c) -> CBool -> CInt -> IO CBool

-- | usage: (@bookCtrlBaseAdvanceSelection obj forward@).
bookCtrlBaseAdvanceSelection :: BookCtrlBase  a -> Bool ->  IO ()
bookCtrlBaseAdvanceSelection _obj forward 
  = withObjectRef "bookCtrlBaseAdvanceSelection" _obj $ \cobj__obj -> 
    wxBookCtrlBase_AdvanceSelection cobj__obj  (toCBool forward)  
foreign import ccall "wxBookCtrlBase_AdvanceSelection" wxBookCtrlBase_AdvanceSelection :: Ptr (TBookCtrlBase a) -> CBool -> IO ()

-- | usage: (@bookCtrlBaseAssignImageList obj imageList@).
bookCtrlBaseAssignImageList :: BookCtrlBase  a -> ImageList  b ->  IO ()
bookCtrlBaseAssignImageList _obj imageList 
  = withObjectRef "bookCtrlBaseAssignImageList" _obj $ \cobj__obj -> 
    withObjectPtr imageList $ \cobj_imageList -> 
    wxBookCtrlBase_AssignImageList cobj__obj  cobj_imageList  
foreign import ccall "wxBookCtrlBase_AssignImageList" wxBookCtrlBase_AssignImageList :: Ptr (TBookCtrlBase a) -> Ptr (TImageList b) -> IO ()

-- | usage: (@bookCtrlBaseChangeSelection obj page@).
bookCtrlBaseChangeSelection :: BookCtrlBase  a -> Int ->  IO Int
bookCtrlBaseChangeSelection _obj page 
  = withIntResult $
    withObjectRef "bookCtrlBaseChangeSelection" _obj $ \cobj__obj -> 
    wxBookCtrlBase_ChangeSelection cobj__obj  (toCInt page)  
foreign import ccall "wxBookCtrlBase_ChangeSelection" wxBookCtrlBase_ChangeSelection :: Ptr (TBookCtrlBase a) -> CInt -> IO CInt

-- | usage: (@bookCtrlBaseCreateFromDefault obj parent winid xy widthheight style name@).
bookCtrlBaseCreateFromDefault :: BookCtrlBase  a -> Window  b -> Int -> Point -> Size -> Int -> String ->  IO Bool
bookCtrlBaseCreateFromDefault _obj _parent winid xy _widthheight style _name 
  = withBoolResult $
    withObjectRef "bookCtrlBaseCreateFromDefault" _obj $ \cobj__obj -> 
    withObjectPtr _parent $ \cobj__parent -> 
    withStringPtr _name $ \cobj__name -> 
    wxBookCtrlBase_CreateFromDefault cobj__obj  cobj__parent  (toCInt winid)  (toCIntPointX xy) (toCIntPointY xy)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt style)  cobj__name  
foreign import ccall "wxBookCtrlBase_CreateFromDefault" wxBookCtrlBase_CreateFromDefault :: Ptr (TBookCtrlBase a) -> Ptr (TWindow b) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (TWxString g) -> IO CBool

-- | usage: (@bookCtrlBaseDeleteAllPages obj@).
bookCtrlBaseDeleteAllPages :: BookCtrlBase  a ->  IO Bool
bookCtrlBaseDeleteAllPages _obj 
  = withBoolResult $
    withObjectRef "bookCtrlBaseDeleteAllPages" _obj $ \cobj__obj -> 
    wxBookCtrlBase_DeleteAllPages cobj__obj  
foreign import ccall "wxBookCtrlBase_DeleteAllPages" wxBookCtrlBase_DeleteAllPages :: Ptr (TBookCtrlBase a) -> IO CBool

-- | usage: (@bookCtrlBaseDeletePage obj page@).
bookCtrlBaseDeletePage :: BookCtrlBase  a -> Int ->  IO Bool
bookCtrlBaseDeletePage _obj page 
  = withBoolResult $
    withObjectRef "bookCtrlBaseDeletePage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_DeletePage cobj__obj  (toCInt page)  
foreign import ccall "wxBookCtrlBase_DeletePage" wxBookCtrlBase_DeletePage :: Ptr (TBookCtrlBase a) -> CInt -> IO CBool

-- | usage: (@bookCtrlBaseFindPage obj page@).
bookCtrlBaseFindPage :: BookCtrlBase  a -> Window  b ->  IO Int
bookCtrlBaseFindPage _obj _page 
  = withIntResult $
    withObjectRef "bookCtrlBaseFindPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    wxBookCtrlBase_FindPage cobj__obj  cobj__page  
foreign import ccall "wxBookCtrlBase_FindPage" wxBookCtrlBase_FindPage :: Ptr (TBookCtrlBase a) -> Ptr (TWindow b) -> IO CInt

-- | usage: (@bookCtrlBaseGetCurrentPage obj@).
bookCtrlBaseGetCurrentPage :: BookCtrlBase  a ->  IO (Window  ())
bookCtrlBaseGetCurrentPage _obj 
  = withObjectResult $
    withObjectRef "bookCtrlBaseGetCurrentPage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetCurrentPage cobj__obj  
foreign import ccall "wxBookCtrlBase_GetCurrentPage" wxBookCtrlBase_GetCurrentPage :: Ptr (TBookCtrlBase a) -> IO (Ptr (TWindow ()))

-- | usage: (@bookCtrlBaseGetImageList obj@).
bookCtrlBaseGetImageList :: BookCtrlBase  a ->  IO (ImageList  ())
bookCtrlBaseGetImageList _obj 
  = withObjectResult $
    withObjectRef "bookCtrlBaseGetImageList" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetImageList cobj__obj  
foreign import ccall "wxBookCtrlBase_GetImageList" wxBookCtrlBase_GetImageList :: Ptr (TBookCtrlBase a) -> IO (Ptr (TImageList ()))

-- | usage: (@bookCtrlBaseGetPage obj page@).
bookCtrlBaseGetPage :: BookCtrlBase  a -> Int ->  IO (Window  ())
bookCtrlBaseGetPage _obj page 
  = withObjectResult $
    withObjectRef "bookCtrlBaseGetPage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetPage cobj__obj  (toCInt page)  
foreign import ccall "wxBookCtrlBase_GetPage" wxBookCtrlBase_GetPage :: Ptr (TBookCtrlBase a) -> CInt -> IO (Ptr (TWindow ()))

-- | usage: (@bookCtrlBaseGetPageCount obj@).
bookCtrlBaseGetPageCount :: BookCtrlBase  a ->  IO Int
bookCtrlBaseGetPageCount _obj 
  = withIntResult $
    withObjectRef "bookCtrlBaseGetPageCount" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetPageCount cobj__obj  
foreign import ccall "wxBookCtrlBase_GetPageCount" wxBookCtrlBase_GetPageCount :: Ptr (TBookCtrlBase a) -> IO CInt

-- | usage: (@bookCtrlBaseGetPageImage obj nPage@).
bookCtrlBaseGetPageImage :: BookCtrlBase  a -> Int ->  IO Int
bookCtrlBaseGetPageImage _obj nPage 
  = withIntResult $
    withObjectRef "bookCtrlBaseGetPageImage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetPageImage cobj__obj  (toCInt nPage)  
foreign import ccall "wxBookCtrlBase_GetPageImage" wxBookCtrlBase_GetPageImage :: Ptr (TBookCtrlBase a) -> CInt -> IO CInt

-- | usage: (@bookCtrlBaseGetPageText obj nPage@).
bookCtrlBaseGetPageText :: BookCtrlBase  a -> Int ->  IO (String)
bookCtrlBaseGetPageText _obj nPage 
  = withManagedStringResult $
    withObjectRef "bookCtrlBaseGetPageText" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetPageText cobj__obj  (toCInt nPage)  
foreign import ccall "wxBookCtrlBase_GetPageText" wxBookCtrlBase_GetPageText :: Ptr (TBookCtrlBase a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@bookCtrlBaseGetSelection obj@).
bookCtrlBaseGetSelection :: BookCtrlBase  a ->  IO Int
bookCtrlBaseGetSelection _obj 
  = withIntResult $
    withObjectRef "bookCtrlBaseGetSelection" _obj $ \cobj__obj -> 
    wxBookCtrlBase_GetSelection cobj__obj  
foreign import ccall "wxBookCtrlBase_GetSelection" wxBookCtrlBase_GetSelection :: Ptr (TBookCtrlBase a) -> IO CInt

-- | usage: (@bookCtrlBaseHitTest obj xy flags@).
bookCtrlBaseHitTest :: BookCtrlBase  a -> Point -> Ptr CInt ->  IO Int
bookCtrlBaseHitTest _obj xy flags 
  = withIntResult $
    withObjectRef "bookCtrlBaseHitTest" _obj $ \cobj__obj -> 
    wxBookCtrlBase_HitTest cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  flags  
foreign import ccall "wxBookCtrlBase_HitTest" wxBookCtrlBase_HitTest :: Ptr (TBookCtrlBase a) -> CInt -> CInt -> Ptr CInt -> IO CInt

-- | usage: (@bookCtrlBaseInsertPage obj index page text select imageId@).
bookCtrlBaseInsertPage :: BookCtrlBase  a -> Int -> Window  c -> String -> Bool -> Int ->  IO Bool
bookCtrlBaseInsertPage _obj index _page _text select imageId 
  = withBoolResult $
    withObjectRef "bookCtrlBaseInsertPage" _obj $ \cobj__obj -> 
    withObjectPtr _page $ \cobj__page -> 
    withStringPtr _text $ \cobj__text -> 
    wxBookCtrlBase_InsertPage cobj__obj  (toCInt index)  cobj__page  cobj__text  (toCBool select)  (toCInt imageId)  
foreign import ccall "wxBookCtrlBase_InsertPage" wxBookCtrlBase_InsertPage :: Ptr (TBookCtrlBase a) -> CInt -> Ptr (TWindow c) -> Ptr (TWxString d) -> CBool -> CInt -> IO CBool

-- | usage: (@bookCtrlBaseRemovePage obj page@).
bookCtrlBaseRemovePage :: BookCtrlBase  a -> Int ->  IO Bool
bookCtrlBaseRemovePage _obj page 
  = withBoolResult $
    withObjectRef "bookCtrlBaseRemovePage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_RemovePage cobj__obj  (toCInt page)  
foreign import ccall "wxBookCtrlBase_RemovePage" wxBookCtrlBase_RemovePage :: Ptr (TBookCtrlBase a) -> CInt -> IO CBool

-- | usage: (@bookCtrlBaseSetImageList obj imageList@).
bookCtrlBaseSetImageList :: BookCtrlBase  a -> ImageList  b ->  IO ()
bookCtrlBaseSetImageList _obj imageList 
  = withObjectRef "bookCtrlBaseSetImageList" _obj $ \cobj__obj -> 
    withObjectPtr imageList $ \cobj_imageList -> 
    wxBookCtrlBase_SetImageList cobj__obj  cobj_imageList  
foreign import ccall "wxBookCtrlBase_SetImageList" wxBookCtrlBase_SetImageList :: Ptr (TBookCtrlBase a) -> Ptr (TImageList b) -> IO ()

-- | usage: (@bookCtrlBaseSetPageImage obj page image@).
bookCtrlBaseSetPageImage :: BookCtrlBase  a -> Int -> Int ->  IO Bool
bookCtrlBaseSetPageImage _obj page image 
  = withBoolResult $
    withObjectRef "bookCtrlBaseSetPageImage" _obj $ \cobj__obj -> 
    wxBookCtrlBase_SetPageImage cobj__obj  (toCInt page)  (toCInt image)  
foreign import ccall "wxBookCtrlBase_SetPageImage" wxBookCtrlBase_SetPageImage :: Ptr (TBookCtrlBase a) -> CInt -> CInt -> IO CBool

-- | usage: (@bookCtrlBaseSetPageSize obj widthheight@).
bookCtrlBaseSetPageSize :: BookCtrlBase  a -> Size ->  IO ()
bookCtrlBaseSetPageSize _obj _widthheight 
  = withObjectRef "bookCtrlBaseSetPageSize" _obj $ \cobj__obj -> 
    wxBookCtrlBase_SetPageSize cobj__obj  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  
foreign import ccall "wxBookCtrlBase_SetPageSize" wxBookCtrlBase_SetPageSize :: Ptr (TBookCtrlBase a) -> CInt -> CInt -> IO ()

-- | usage: (@bookCtrlBaseSetPageText obj page text@).
bookCtrlBaseSetPageText :: BookCtrlBase  a -> Int -> String ->  IO Bool
bookCtrlBaseSetPageText _obj page _text 
  = withBoolResult $
    withObjectRef "bookCtrlBaseSetPageText" _obj $ \cobj__obj -> 
    withStringPtr _text $ \cobj__text -> 
    wxBookCtrlBase_SetPageText cobj__obj  (toCInt page)  cobj__text  
foreign import ccall "wxBookCtrlBase_SetPageText" wxBookCtrlBase_SetPageText :: Ptr (TBookCtrlBase a) -> CInt -> Ptr (TWxString c) -> IO CBool

-- | usage: (@bookCtrlBaseSetSelection obj page@).
bookCtrlBaseSetSelection :: BookCtrlBase  a -> Int ->  IO Int
bookCtrlBaseSetSelection _obj page 
  = withIntResult $
    withObjectRef "bookCtrlBaseSetSelection" _obj $ \cobj__obj -> 
    wxBookCtrlBase_SetSelection cobj__obj  (toCInt page)  
foreign import ccall "wxBookCtrlBase_SetSelection" wxBookCtrlBase_SetSelection :: Ptr (TBookCtrlBase a) -> CInt -> IO CInt

-- | usage: (@bookCtrlEventCreate commandType winid nSel nOldSel@).
bookCtrlEventCreate :: Int -> Int -> Int -> Int ->  IO (BookCtrlEvent  ())
bookCtrlEventCreate commandType winid nSel nOldSel 
  = withObjectResult $
    wxBookCtrlEvent_Create (toCInt commandType)  (toCInt winid)  (toCInt nSel)  (toCInt nOldSel)  
foreign import ccall "wxBookCtrlEvent_Create" wxBookCtrlEvent_Create :: CInt -> CInt -> CInt -> CInt -> IO (Ptr (TBookCtrlEvent ()))

-- | usage: (@bookCtrlEventGetOldSelection obj@).
bookCtrlEventGetOldSelection :: BookCtrlEvent  a ->  IO Int
bookCtrlEventGetOldSelection _obj 
  = withIntResult $
    withObjectRef "bookCtrlEventGetOldSelection" _obj $ \cobj__obj -> 
    wxBookCtrlEvent_GetOldSelection cobj__obj  
foreign import ccall "wxBookCtrlEvent_GetOldSelection" wxBookCtrlEvent_GetOldSelection :: Ptr (TBookCtrlEvent a) -> IO CInt

-- | usage: (@bookCtrlEventGetSelection obj@).
bookCtrlEventGetSelection :: BookCtrlEvent  a ->  IO Int
bookCtrlEventGetSelection _obj 
  = withIntResult $
    withObjectRef "bookCtrlEventGetSelection" _obj $ \cobj__obj -> 
    wxBookCtrlEvent_GetSelection cobj__obj  
foreign import ccall "wxBookCtrlEvent_GetSelection" wxBookCtrlEvent_GetSelection :: Ptr (TBookCtrlEvent a) -> IO CInt

-- | usage: (@boolPropertyCreate label name value@).
boolPropertyCreate :: String -> String -> Bool ->  IO (BoolProperty  ())
boolPropertyCreate label name value 
  = withObjectResult $
    withStringPtr label $ \cobj_label -> 
    withStringPtr name $ \cobj_name -> 
    wxBoolProperty_Create cobj_label  cobj_name  (toCBool value)  
foreign import ccall "wxBoolProperty_Create" wxBoolProperty_Create :: Ptr (TWxString a) -> Ptr (TWxString b) -> CBool -> IO (Ptr (TBoolProperty ()))

-- | 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: (@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: (@colorPickerCtrlCreate parent id colour xywh style@).
colorPickerCtrlCreate :: Window  a -> Id -> Color -> Rect -> Int ->  IO (ColourPickerCtrl  ())
colorPickerCtrlCreate parent id colour xywh style 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withColourPtr colour $ \cobj_colour -> 
    wxColorPickerCtrl_Create cobj_parent  (toCInt id)  cobj_colour  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt style)  
foreign import ccall "wxColorPickerCtrl_Create" wxColorPickerCtrl_Create :: Ptr (TWindow a) -> CInt -> Ptr (TColour c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TColourPickerCtrl ()))

-- | usage: (@colorPickerCtrlGetColour self@).
colorPickerCtrlGetColour :: ColourPickerCtrl  a ->  IO (Color)
colorPickerCtrlGetColour self 
  = withRefColour $ \pref -> 
    withObjectPtr self $ \cobj_self -> 
    wxColorPickerCtrl_GetColour cobj_self   pref
foreign import ccall "wxColorPickerCtrl_GetColour" wxColorPickerCtrl_GetColour :: Ptr (TColourPickerCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@colorPickerCtrlSetColour self colour@).
colorPickerCtrlSetColour :: ColourPickerCtrl  a -> Color ->  IO ()
colorPickerCtrlSetColour self colour 
  = withObjectPtr self $ \cobj_self -> 
    withColourPtr colour $ \cobj_colour -> 
    wxColorPickerCtrl_SetColour cobj_self  cobj_colour  
foreign import ccall "wxColorPickerCtrl_SetColour" wxColorPickerCtrl_SetColour :: Ptr (TColourPickerCtrl a) -> Ptr (TColour b) -> IO ()

-- | 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: (@comboBoxSetValue obj value@).
comboBoxSetValue :: ComboBox  a -> String ->  IO ()
comboBoxSetValue _obj value 
  = withObjectRef "comboBoxSetValue" _obj $ \cobj__obj -> 
    withStringPtr value $ \cobj_value -> 
    wxComboBox_SetValue cobj__obj  cobj_value  
foreign import ccall "wxComboBox_SetValue" wxComboBox_SetValue :: Ptr (TComboBox a) -> Ptr (TWxString b) -> 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: (@datePropertyCreate label name value@).
datePropertyCreate :: String -> String -> DateTime  c ->  IO (DateProperty  ())
datePropertyCreate label name value 
  = withObjectResult $
    withStringPtr label $ \cobj_label -> 
    withStringPtr name $ \cobj_name -> 
    withObjectPtr value $ \cobj_value -> 
    wxDateProperty_Create cobj_label  cobj_name  cobj_value  
foreign import ccall "wxDateProperty_Create" wxDateProperty_Create :: Ptr (TWxString a) -> Ptr (TWxString b) -> Ptr (TDateTime c) -> IO (Ptr (TDateProperty ()))

-- | 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: (@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: (@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

-- | usage: (@dcGetPixel2 obj xy@).
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: (@dcSetDeviceClippingRegion obj region@).
dcSetDeviceClippingRegion :: DC  a -> Region  b ->  IO ()
dcSetDeviceClippingRegion _obj region 
  = withObjectRef "dcSetDeviceClippingRegion" _obj $ \cobj__obj -> 
    withObjectPtr region $ \cobj_region -> 
    wxDC_SetDeviceClippingRegion cobj__obj  cobj_region  
foreign import ccall "wxDC_SetDeviceClippingRegion" wxDC_SetDeviceClippingRegion :: 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: (@fileInputStreamCreate ofileName@).
fileInputStreamCreate :: String ->  IO (FileInputStream  ())
fileInputStreamCreate ofileName 
  = withObjectResult $
    withStringPtr ofileName $ \cobj_ofileName -> 
    wxFileInputStream_Create cobj_ofileName  
foreign import ccall "wxFileInputStream_Create" wxFileInputStream_Create :: Ptr (TWxString a) -> IO (Ptr (TFileInputStream ()))

-- | usage: (@fileInputStreamDelete self@).
fileInputStreamDelete :: FileInputStream  a ->  IO ()
fileInputStreamDelete self 
  = withObjectRef "fileInputStreamDelete" self $ \cobj_self -> 
    wxFileInputStream_Delete cobj_self  
foreign import ccall "wxFileInputStream_Delete" wxFileInputStream_Delete :: Ptr (TFileInputStream a) -> IO ()

-- | usage: (@fileInputStreamIsOk self@).
fileInputStreamIsOk :: FileInputStream  a ->  IO Bool
fileInputStreamIsOk self 
  = withBoolResult $
    withObjectRef "fileInputStreamIsOk" self $ \cobj_self -> 
    wxFileInputStream_IsOk cobj_self  
foreign import ccall "wxFileInputStream_IsOk" wxFileInputStream_IsOk :: Ptr (TFileInputStream a) -> IO CBool

-- | usage: (@fileOutputStreamCreate ofileName@).
fileOutputStreamCreate :: String ->  IO (FileOutputStream  ())
fileOutputStreamCreate ofileName 
  = withObjectResult $
    withStringPtr ofileName $ \cobj_ofileName -> 
    wxFileOutputStream_Create cobj_ofileName  
foreign import ccall "wxFileOutputStream_Create" wxFileOutputStream_Create :: Ptr (TWxString a) -> IO (Ptr (TFileOutputStream ()))

-- | usage: (@fileOutputStreamDelete self@).
fileOutputStreamDelete :: FileOutputStream  a ->  IO ()
fileOutputStreamDelete self 
  = withObjectRef "fileOutputStreamDelete" self $ \cobj_self -> 
    wxFileOutputStream_Delete cobj_self  
foreign import ccall "wxFileOutputStream_Delete" wxFileOutputStream_Delete :: Ptr (TFileOutputStream a) -> IO ()

-- | usage: (@fileOutputStreamIsOk self@).
fileOutputStreamIsOk :: FileOutputStream  a ->  IO Bool
fileOutputStreamIsOk self 
  = withBoolResult $
    withObjectRef "fileOutputStreamIsOk" self $ \cobj_self -> 
    wxFileOutputStream_IsOk cobj_self  
foreign import ccall "wxFileOutputStream_IsOk" wxFileOutputStream_IsOk :: Ptr (TFileOutputStream a) -> IO CBool

-- | usage: (@filePropertyCreate label name value@).
filePropertyCreate :: String -> String -> String ->  IO (FileProperty  ())
filePropertyCreate label name value 
  = withObjectResult $
    withStringPtr label $ \cobj_label -> 
    withStringPtr name $ \cobj_name -> 
    withStringPtr value $ \cobj_value -> 
    wxFileProperty_Create cobj_label  cobj_name  cobj_value  
foreign import ccall "wxFileProperty_Create" wxFileProperty_Create :: Ptr (TWxString a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO (Ptr (TFileProperty ()))

-- | 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: (@floatPropertyCreate label name value@).
floatPropertyCreate :: String -> String -> Float ->  IO (FloatProperty  ())
floatPropertyCreate label name value 
  = withObjectResult $
    withStringPtr label $ \cobj_label -> 
    withStringPtr name $ \cobj_name -> 
    wxFloatProperty_Create cobj_label  cobj_name  value  
foreign import ccall "wxFloatProperty_Create" wxFloatProperty_Create :: Ptr (TWxString a) -> Ptr (TWxString b) -> Float -> IO (Ptr (TFloatProperty ()))

-- | 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: (@gcdcCreate dc@).
gcdcCreate :: WindowDC  a ->  IO (GCDC  ())
gcdcCreate dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGcdc_Create cobj_dc  
foreign import ccall "wxGcdc_Create" wxGcdc_Create :: Ptr (TWindowDC a) -> IO (Ptr (TGCDC ()))

-- | usage: (@gcdcCreateFromMemory dc@).
gcdcCreateFromMemory :: MemoryDC  a ->  IO (GCDC  ())
gcdcCreateFromMemory dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGcdc_CreateFromMemory cobj_dc  
foreign import ccall "wxGcdc_CreateFromMemory" wxGcdc_CreateFromMemory :: Ptr (TMemoryDC a) -> IO (Ptr (TGCDC ()))

-- | usage: (@gcdcCreateFromPrinter dc@).
gcdcCreateFromPrinter :: PrinterDC  a ->  IO (GCDC  ())
gcdcCreateFromPrinter dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGcdc_CreateFromPrinter cobj_dc  
foreign import ccall "wxGcdc_CreateFromPrinter" wxGcdc_CreateFromPrinter :: Ptr (TPrinterDC a) -> IO (Ptr (TGCDC ()))

-- | usage: (@gcdcDelete self@).
gcdcDelete :: GCDC  a ->  IO ()
gcdcDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxGcdc_Delete cobj_self  
foreign import ccall "wxGcdc_Delete" wxGcdc_Delete :: Ptr (TGCDC a) -> IO ()

-- | usage: (@gcdcGetGraphicsContext self@).
gcdcGetGraphicsContext :: GCDC  a ->  IO (GraphicsContext  ())
gcdcGetGraphicsContext self 
  = withObjectResult $
    withObjectPtr self $ \cobj_self -> 
    wxGcdc_GetGraphicsContext cobj_self  
foreign import ccall "wxGcdc_GetGraphicsContext" wxGcdc_GetGraphicsContext :: Ptr (TGCDC a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@gcdcSetGraphicsContext self gc@).
gcdcSetGraphicsContext :: GCDC  a -> GraphicsContext  b ->  IO ()
gcdcSetGraphicsContext self gc 
  = withObjectPtr self $ \cobj_self -> 
    withObjectPtr gc $ \cobj_gc -> 
    wxGcdc_SetGraphicsContext cobj_self  cobj_gc  
foreign import ccall "wxGcdc_SetGraphicsContext" wxGcdc_SetGraphicsContext :: Ptr (TGCDC a) -> Ptr (TGraphicsContext b) -> 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 ()))

-- | usage: (@getApplicationDir@).
getApplicationDir ::  IO (String)
getApplicationDir 
  = withManagedStringResult $
    wx_wxGetApplicationDir 
foreign import ccall "wxGetApplicationDir" wx_wxGetApplicationDir :: IO (Ptr (TWxString ()))

-- | usage: (@getApplicationPath@).
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: (@glCanvasCreate parent windowID attributes xywh stl title palette@).
glCanvasCreate :: Window  a -> Int -> Ptr CInt -> Rect -> Style -> String -> Palette  g ->  IO (GLCanvas  ())
glCanvasCreate parent windowID attributes xywh _stl title palette 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withStringPtr title $ \cobj_title -> 
    withObjectPtr palette $ \cobj_palette -> 
    wxGLCanvas_Create cobj_parent  (toCInt windowID)  attributes  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt _stl)  cobj_title  cobj_palette  
foreign import ccall "wxGLCanvas_Create" wxGLCanvas_Create :: Ptr (TWindow a) -> CInt -> Ptr CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (TWxString f) -> Ptr (TPalette g) -> IO (Ptr (TGLCanvas ()))

-- | usage: (@glCanvasIsDisplaySupported attributes@).
glCanvasIsDisplaySupported :: Ptr CInt ->  IO Bool
glCanvasIsDisplaySupported attributes 
  = withBoolResult $
    wxGLCanvas_IsDisplaySupported attributes  
foreign import ccall "wxGLCanvas_IsDisplaySupported" wxGLCanvas_IsDisplaySupported :: Ptr CInt -> IO CBool

-- | usage: (@glCanvasIsExtensionSupported extension@).
glCanvasIsExtensionSupported :: String ->  IO Bool
glCanvasIsExtensionSupported extension 
  = withBoolResult $
    withStringPtr extension $ \cobj_extension -> 
    wxGLCanvas_IsExtensionSupported cobj_extension  
foreign import ccall "wxGLCanvas_IsExtensionSupported" wxGLCanvas_IsExtensionSupported :: Ptr (TWxString a) -> IO CBool

-- | usage: (@glCanvasSetColour self colour@).
glCanvasSetColour :: GLCanvas  a -> Color ->  IO Bool
glCanvasSetColour self colour 
  = withBoolResult $
    withObjectRef "glCanvasSetColour" self $ \cobj_self -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGLCanvas_SetColour cobj_self  cobj_colour  
foreign import ccall "wxGLCanvas_SetColour" wxGLCanvas_SetColour :: Ptr (TGLCanvas a) -> Ptr (TColour b) -> IO CBool

-- | usage: (@glCanvasSetCurrent self ctxt@).
glCanvasSetCurrent :: GLCanvas  a -> GLContext  b ->  IO Bool
glCanvasSetCurrent self ctxt 
  = withBoolResult $
    withObjectRef "glCanvasSetCurrent" self $ \cobj_self -> 
    withObjectPtr ctxt $ \cobj_ctxt -> 
    wxGLCanvas_SetCurrent cobj_self  cobj_ctxt  
foreign import ccall "wxGLCanvas_SetCurrent" wxGLCanvas_SetCurrent :: Ptr (TGLCanvas a) -> Ptr (TGLContext b) -> IO CBool

-- | usage: (@glCanvasSwapBuffers self@).
glCanvasSwapBuffers :: GLCanvas  a ->  IO Bool
glCanvasSwapBuffers self 
  = withBoolResult $
    withObjectRef "glCanvasSwapBuffers" self $ \cobj_self -> 
    wxGLCanvas_SwapBuffers cobj_self  
foreign import ccall "wxGLCanvas_SwapBuffers" wxGLCanvas_SwapBuffers :: Ptr (TGLCanvas a) -> IO CBool

-- | usage: (@glContextCreate win other@).
glContextCreate :: GLCanvas  a -> GLContext  b ->  IO (GLContext  ())
glContextCreate win other 
  = withObjectResult $
    withObjectPtr win $ \cobj_win -> 
    withObjectPtr other $ \cobj_other -> 
    wxGLContext_Create cobj_win  cobj_other  
foreign import ccall "wxGLContext_Create" wxGLContext_Create :: Ptr (TGLCanvas a) -> Ptr (TGLContext b) -> IO (Ptr (TGLContext ()))

-- | usage: (@glContextCreateFromNull win@).
glContextCreateFromNull :: GLCanvas  a ->  IO (GLContext  ())
glContextCreateFromNull win 
  = withObjectResult $
    withObjectPtr win $ \cobj_win -> 
    wxGLContext_CreateFromNull cobj_win  
foreign import ccall "wxGLContext_CreateFromNull" wxGLContext_CreateFromNull :: Ptr (TGLCanvas a) -> IO (Ptr (TGLContext ()))

-- | usage: (@glContextSetCurrent self win@).
glContextSetCurrent :: GLContext  a -> GLCanvas  b ->  IO Bool
glContextSetCurrent self win 
  = withBoolResult $
    withObjectRef "glContextSetCurrent" self $ \cobj_self -> 
    withObjectPtr win $ \cobj_win -> 
    wxGLContext_SetCurrent cobj_self  cobj_win  
foreign import ccall "wxGLContext_SetCurrent" wxGLContext_SetCurrent :: Ptr (TGLContext a) -> Ptr (TGLCanvas b) -> IO CBool

-- | 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: (@graphicsContextCreateDefaultMatrix self@).
graphicsContextCreateDefaultMatrix :: GraphicsContext  a ->  IO (GraphicsMatrix  ())
graphicsContextCreateDefaultMatrix self 
  = withObjectResult $
    withObjectRef "graphicsContextCreateDefaultMatrix" self $ \cobj_self -> 
    wxGraphicsContext_CreateDefaultMatrix cobj_self  
foreign import ccall "wxGraphicsContext_CreateDefaultMatrix" wxGraphicsContext_CreateDefaultMatrix :: Ptr (TGraphicsContext a) -> IO (Ptr (TGraphicsMatrix ()))

-- | usage: (@graphicsContextCreateFromMemory dc@).
graphicsContextCreateFromMemory :: MemoryDC  a ->  IO (GraphicsContext  ())
graphicsContextCreateFromMemory dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGraphicsContext_CreateFromMemory cobj_dc  
foreign import ccall "wxGraphicsContext_CreateFromMemory" wxGraphicsContext_CreateFromMemory :: Ptr (TMemoryDC 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: (@graphicsContextCreateFromPrinter dc@).
graphicsContextCreateFromPrinter :: PrinterDC  a ->  IO (GraphicsContext  ())
graphicsContextCreateFromPrinter dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGraphicsContext_CreateFromPrinter cobj_dc  
foreign import ccall "wxGraphicsContext_CreateFromPrinter" wxGraphicsContext_CreateFromPrinter :: Ptr (TPrinterDC 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: (@graphicsContextCreateMatrix self a b c d tx ty@).
graphicsContextCreateMatrix :: GraphicsContext  a -> Double -> Double -> Double -> Double -> Double -> Double ->  IO (GraphicsMatrix  ())
graphicsContextCreateMatrix self a b c d tx ty 
  = withObjectResult $
    withObjectRef "graphicsContextCreateMatrix" self $ \cobj_self -> 
    wxGraphicsContext_CreateMatrix cobj_self  a  b  c  d  tx  ty  
foreign import ccall "wxGraphicsContext_CreateMatrix" wxGraphicsContext_CreateMatrix :: Ptr (TGraphicsContext a) -> Double -> Double -> Double -> Double -> Double -> Double -> IO (Ptr (TGraphicsMatrix ()))

-- | usage: (@graphicsContextCreatePath self@).
graphicsContextCreatePath :: GraphicsContext  a ->  IO (GraphicsPath  ())
graphicsContextCreatePath self 
  = withObjectResult $
    withObjectRef "graphicsContextCreatePath" self $ \cobj_self -> 
    wxGraphicsContext_CreatePath cobj_self  
foreign import ccall "wxGraphicsContext_CreatePath" wxGraphicsContext_CreatePath :: Ptr (TGraphicsContext a) -> IO (Ptr (TGraphicsPath ()))

-- | 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: (@graphicsContextPopState self@).
graphicsContextPopState :: GraphicsContext  a ->  IO ()
graphicsContextPopState self 
  = withObjectRef "graphicsContextPopState" self $ \cobj_self -> 
    wxGraphicsContext_PopState cobj_self  
foreign import ccall "wxGraphicsContext_PopState" wxGraphicsContext_PopState :: Ptr (TGraphicsContext a) -> IO ()

-- | usage: (@graphicsContextPushState self@).
graphicsContextPushState :: GraphicsContext  a ->  IO ()
graphicsContextPushState self 
  = withObjectRef "graphicsContextPushState" self $ \cobj_self -> 
    wxGraphicsContext_PushState cobj_self  
foreign import ccall "wxGraphicsContext_PushState" wxGraphicsContext_PushState :: Ptr (TGraphicsContext a) -> 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: (@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: (@graphicsRendererCreatePath self@).
graphicsRendererCreatePath :: GraphicsRenderer  a ->  IO (GraphicsPath  ())
graphicsRendererCreatePath self 
  = withObjectResult $
    withObjectRef "graphicsRendererCreatePath" self $ \cobj_self -> 
    wxGraphicsRenderer_CreatePath cobj_self  
foreign import ccall "wxGraphicsRenderer_CreatePath" wxGraphicsRenderer_CreatePath :: Ptr (TGraphicsRenderer a) -> IO (Ptr (TGraphicsPath ()))

-- | 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: (@gridCanDragColSize obj col@).
gridCanDragColSize :: Grid  a -> Int ->  IO Bool
gridCanDragColSize _obj col 
  = withBoolResult $
    withObjectRef "gridCanDragColSize" _obj $ \cobj__obj -> 
    wxGrid_CanDragColSize cobj__obj  (toCInt col)  
foreign import ccall "wxGrid_CanDragColSize" wxGrid_CanDragColSize :: Ptr (TGrid a) -> CInt -> 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 row@).
gridCanDragRowSize :: Grid  a -> Int ->  IO Bool
gridCanDragRowSize _obj row 
  = withBoolResult $
    withObjectRef "gridCanDragRowSize" _obj $ \cobj__obj -> 
    wxGrid_CanDragRowSize cobj__obj  (toCInt row)  
foreign import ccall "wxGrid_CanDragRowSize" wxGrid_CanDragRowSize :: Ptr (TGrid a) -> CInt -> 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: (@gridCellAutoWrapStringRendererCtor@).
gridCellAutoWrapStringRendererCtor ::  IO (GridCellAutoWrapStringRenderer  ())
gridCellAutoWrapStringRendererCtor 
  = withObjectResult $
    wxGridCellAutoWrapStringRenderer_Ctor 
foreign import ccall "wxGridCellAutoWrapStringRenderer_Ctor" wxGridCellAutoWrapStringRenderer_Ctor :: IO (Ptr (TGridCellAutoWrapStringRenderer ()))

-- | 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 oldStr newStr@).
gridCellEditorEndEdit :: GridCellEditor  a -> Int -> Int -> Grid  d -> String -> String ->  IO Int
gridCellEditorEndEdit _obj row col grid oldStr newStr 
  = withIntResult $
    withObjectRef "gridCellEditorEndEdit" _obj $ \cobj__obj -> 
    withObjectPtr grid $ \cobj_grid -> 
    withStringPtr oldStr $ \cobj_oldStr -> 
    withStringPtr newStr $ \cobj_newStr -> 
    wxGridCellEditor_EndEdit cobj__obj  (toCInt row)  (toCInt col)  cobj_grid  cobj_oldStr  cobj_newStr  
foreign import ccall "wxGridCellEditor_EndEdit" wxGridCellEditor_EndEdit :: Ptr (TGridCellEditor a) -> CInt -> CInt -> Ptr (TGrid d) -> Ptr (TWxString e) -> Ptr (TWxString f) -> 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 dc xywh attr@).
gridCellEditorPaintBackground :: GridCellEditor  a -> DC  b -> Rect -> GridCellAttr  d ->  IO ()
gridCellEditorPaintBackground _obj dc xywh attr 
  = withObjectRef "gridCellEditorPaintBackground" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGridCellEditor_PaintBackground cobj__obj  cobj_dc  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  cobj_attr  
foreign import ccall "wxGridCellEditor_PaintBackground" wxGridCellEditor_PaintBackground :: Ptr (TGridCellEditor a) -> Ptr (TDC b) -> CInt -> CInt -> CInt -> CInt -> Ptr (TGridCellAttr d) -> 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: (@gridCellNumberRendererCtor@).
gridCellNumberRendererCtor ::  IO (GridCellNumberRenderer  ())
gridCellNumberRendererCtor 
  = withObjectResult $
    wxGridCellNumberRenderer_Ctor 
foreign import ccall "wxGridCellNumberRenderer_Ctor" wxGridCellNumberRenderer_Ctor :: IO (Ptr (TGridCellNumberRenderer ()))

-- | 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: (@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: (@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: (@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: (@gridGetCellSize obj row col@).
gridGetCellSize :: Grid  a -> Int -> Int ->  IO Size
gridGetCellSize _obj row col 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetCellSize" _obj $ \cobj__obj -> 
    wxGrid_GetCellSize cobj__obj  (toCInt row)  (toCInt col)   pw ph
foreign import ccall "wxGrid_GetCellSize" wxGrid_GetCellSize :: Ptr (TGrid a) -> CInt -> CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | 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: (@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: (@gridSetCellSize obj row col srowscol@).
gridSetCellSize :: Grid  a -> Int -> Int -> Size ->  IO ()
gridSetCellSize _obj row col srowscol 
  = withObjectRef "gridSetCellSize" _obj $ \cobj__obj -> 
    wxGrid_SetCellSize cobj__obj  (toCInt row)  (toCInt col)  (toCIntSizeW srowscol) (toCIntSizeH srowscol)  
foreign import ccall "wxGrid_SetCellSize" wxGrid_SetCellSize :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> CInt -> 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: (@hyperlinkCtrlCreate parent id label url xywh style@).
hyperlinkCtrlCreate :: Window  a -> Id -> String -> String -> Rect -> Int ->  IO (HyperlinkCtrl  ())
hyperlinkCtrlCreate parent id label url xywh style 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withStringPtr label $ \cobj_label -> 
    withStringPtr url $ \cobj_url -> 
    wxHyperlinkCtrl_Create cobj_parent  (toCInt id)  cobj_label  cobj_url  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt style)  
foreign import ccall "wxHyperlinkCtrl_Create" wxHyperlinkCtrl_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> Ptr (TWxString d) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (THyperlinkCtrl ()))

-- | usage: (@hyperlinkCtrlGetHoverColour self@).
hyperlinkCtrlGetHoverColour :: HyperlinkCtrl  a ->  IO (Color)
hyperlinkCtrlGetHoverColour self 
  = withManagedColourResult $
    withObjectRef "hyperlinkCtrlGetHoverColour" self $ \cobj_self -> 
    wxHyperlinkCtrl_GetHoverColour cobj_self  
foreign import ccall "wxHyperlinkCtrl_GetHoverColour" wxHyperlinkCtrl_GetHoverColour :: Ptr (THyperlinkCtrl a) -> IO (Ptr (TColour ()))

-- | usage: (@hyperlinkCtrlGetNormalColour self@).
hyperlinkCtrlGetNormalColour :: HyperlinkCtrl  a ->  IO (Color)
hyperlinkCtrlGetNormalColour self 
  = withManagedColourResult $
    withObjectRef "hyperlinkCtrlGetNormalColour" self $ \cobj_self -> 
    wxHyperlinkCtrl_GetNormalColour cobj_self  
foreign import ccall "wxHyperlinkCtrl_GetNormalColour" wxHyperlinkCtrl_GetNormalColour :: Ptr (THyperlinkCtrl a) -> IO (Ptr (TColour ()))

-- | usage: (@hyperlinkCtrlGetURL self@).
hyperlinkCtrlGetURL :: HyperlinkCtrl  a ->  IO (String)
hyperlinkCtrlGetURL self 
  = withManagedStringResult $
    withObjectRef "hyperlinkCtrlGetURL" self $ \cobj_self -> 
    wxHyperlinkCtrl_GetURL cobj_self  
foreign import ccall "wxHyperlinkCtrl_GetURL" wxHyperlinkCtrl_GetURL :: Ptr (THyperlinkCtrl a) -> IO (Ptr (TWxString ()))

-- | usage: (@hyperlinkCtrlGetVisited self@).
hyperlinkCtrlGetVisited :: HyperlinkCtrl  a ->  IO Bool
hyperlinkCtrlGetVisited self 
  = withBoolResult $
    withObjectRef "hyperlinkCtrlGetVisited" self $ \cobj_self -> 
    wxHyperlinkCtrl_GetVisited cobj_self  
foreign import ccall "wxHyperlinkCtrl_GetVisited" wxHyperlinkCtrl_GetVisited :: Ptr (THyperlinkCtrl a) -> IO CBool

-- | usage: (@hyperlinkCtrlGetVisitedColour self@).
hyperlinkCtrlGetVisitedColour :: HyperlinkCtrl  a ->  IO (Color)
hyperlinkCtrlGetVisitedColour self 
  = withManagedColourResult $
    withObjectRef "hyperlinkCtrlGetVisitedColour" self $ \cobj_self -> 
    wxHyperlinkCtrl_GetVisitedColour cobj_self  
foreign import ccall "wxHyperlinkCtrl_GetVisitedColour" wxHyperlinkCtrl_GetVisitedColour :: Ptr (THyperlinkCtrl a) -> IO (Ptr (TColour ()))

-- | usage: (@hyperlinkCtrlSetHoverColour self colour@).
hyperlinkCtrlSetHoverColour :: HyperlinkCtrl  a -> Color ->  IO ()
hyperlinkCtrlSetHoverColour self colour 
  = withObjectRef "hyperlinkCtrlSetHoverColour" self $ \cobj_self -> 
    withColourPtr colour $ \cobj_colour -> 
    wxHyperlinkCtrl_SetHoverColour cobj_self  cobj_colour  
foreign import ccall "wxHyperlinkCtrl_SetHoverColour" wxHyperlinkCtrl_SetHoverColour :: Ptr (THyperlinkCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@hyperlinkCtrlSetNormalColour self colour@).
hyperlinkCtrlSetNormalColour :: HyperlinkCtrl  a -> Color ->  IO ()
hyperlinkCtrlSetNormalColour self colour 
  = withObjectRef "hyperlinkCtrlSetNormalColour" self $ \cobj_self -> 
    withColourPtr colour $ \cobj_colour -> 
    wxHyperlinkCtrl_SetNormalColour cobj_self  cobj_colour  
foreign import ccall "wxHyperlinkCtrl_SetNormalColour" wxHyperlinkCtrl_SetNormalColour :: Ptr (THyperlinkCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@hyperlinkCtrlSetURL self url@).
hyperlinkCtrlSetURL :: HyperlinkCtrl  a -> String ->  IO ()
hyperlinkCtrlSetURL self url 
  = withObjectRef "hyperlinkCtrlSetURL" self $ \cobj_self -> 
    withStringPtr url $ \cobj_url -> 
    wxHyperlinkCtrl_SetURL cobj_self  cobj_url  
foreign import ccall "wxHyperlinkCtrl_SetURL" wxHyperlinkCtrl_SetURL :: Ptr (THyperlinkCtrl a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@hyperlinkCtrlSetVisited self visited@).
hyperlinkCtrlSetVisited :: HyperlinkCtrl  a -> Bool ->  IO ()
hyperlinkCtrlSetVisited self visited 
  = withObjectRef "hyperlinkCtrlSetVisited" self $ \cobj_self -> 
    wxHyperlinkCtrl_SetVisited cobj_self  (toCBool visited)  
foreign import ccall "wxHyperlinkCtrl_SetVisited" wxHyperlinkCtrl_SetVisited :: Ptr (THyperlinkCtrl a) -> CBool -> IO ()

-- | usage: (@hyperlinkCtrlSetVisitedColour self colour@).
hyperlinkCtrlSetVisitedColour :: HyperlinkCtrl  a -> Color ->  IO ()
hyperlinkCtrlSetVisitedColour self colour 
  = withObjectRef "hyperlinkCtrlSetVisitedColour" self $ \cobj_self -> 
    withColourPtr colour $ \cobj_colour -> 
    wxHyperlinkCtrl_SetVisitedColour cobj_self  cobj_colour  
foreign import ccall "wxHyperlinkCtrl_SetVisitedColour" wxHyperlinkCtrl_SetVisitedColour :: Ptr (THyperlinkCtrl a) -> Ptr (TColour b) -> 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: (@imageCopy obj@).
imageCopy :: Image  a ->  IO (Image  ())
imageCopy _obj 
  = withRefImage $ \pref -> 
    withObjectRef "imageCopy" _obj $ \cobj__obj -> 
    wxImage_Copy cobj__obj   pref
foreign import ccall "wxImage_Copy" wxImage_Copy :: Ptr (TImage a) -> Ptr (TImage ()) -> IO ()

-- | 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 widthheight datalength@).
imageCreateFromByteString :: Size -> B.ByteString ->  IO (Image  ())
imageCreateFromByteString widthheight datalength 
  = withManagedObjectResult $
    B.useAsCStringLen datalength $ \(bs_datalength, bslen_datalength)  -> 
    wxImage_CreateFromByteString (toCIntSizeW widthheight) (toCIntSizeH widthheight)  bs_datalength bslen_datalength  
foreign import ccall "wxImage_CreateFromByteString" wxImage_CreateFromByteString :: CInt -> CInt -> Ptr CChar -> Int -> 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 widthheight datalength@).
imageCreateFromLazyByteString :: Size -> LB.ByteString ->  IO (Image  ())
imageCreateFromLazyByteString widthheight datalength 
  = withManagedObjectResult $
    withArray (LB.unpack datalength) $ \bs_datalength -> 
    wxImage_CreateFromLazyByteString (toCIntSizeW widthheight) (toCIntSizeH widthheight)  bs_datalength (fromIntegral $ LB.length datalength)  
foreign import ccall "wxImage_CreateFromLazyByteString" wxImage_CreateFromLazyByteString :: CInt -> CInt -> Ptr Word8 -> Int -> 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: (@imageGetType obj@).
imageGetType :: Image  a ->  IO Int
imageGetType _obj 
  = withIntResult $
    withObjectRef "imageGetType" _obj $ \cobj__obj -> 
    wxImage_GetType cobj__obj  
foreign import ccall "wxImage_GetType" wxImage_GetType :: Ptr (TImage a) -> IO CInt

-- | 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: (@imageLoadStream obj name wxtype index@).
imageLoadStream :: Image  a -> InputStream  b -> Int -> Int ->  IO Bool
imageLoadStream _obj name wxtype index 
  = withBoolResult $
    withObjectRef "imageLoadStream" _obj $ \cobj__obj -> 
    withObjectPtr name $ \cobj_name -> 
    wxImage_LoadStream cobj__obj  cobj_name  (toCInt wxtype)  (toCInt index)  
foreign import ccall "wxImage_LoadStream" wxImage_LoadStream :: Ptr (TImage a) -> Ptr (TInputStream b) -> CInt -> 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: (@imageRescaleEx obj widthheight quality@).
imageRescaleEx :: Image  a -> Size -> Int ->  IO ()
imageRescaleEx _obj widthheight quality 
  = withObjectRef "imageRescaleEx" _obj $ \cobj__obj -> 
    wxImage_RescaleEx cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  (toCInt quality)  
foreign import ccall "wxImage_RescaleEx" wxImage_RescaleEx :: Ptr (TImage a) -> CInt -> 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: (@imageSaveStream obj stream wxtype@).
imageSaveStream :: Image  a -> OutputStream  b -> Int ->  IO Bool
imageSaveStream _obj stream wxtype 
  = withBoolResult $
    withObjectRef "imageSaveStream" _obj $ \cobj__obj -> 
    withObjectPtr stream $ \cobj_stream -> 
    wxImage_SaveStream cobj__obj  cobj_stream  (toCInt wxtype)  
foreign import ccall "wxImage_SaveStream" wxImage_SaveStream :: Ptr (TImage a) -> Ptr (TOutputStream 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: (@imageScaleEx obj widthheight quality@).
imageScaleEx :: Image  a -> Size -> Int ->  IO (Image  ())
imageScaleEx _obj widthheight quality 
  = withRefImage $ \pref -> 
    withObjectRef "imageScaleEx" _obj $ \cobj__obj -> 
    wxImage_ScaleEx cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  (toCInt quality)   pref
foreign import ccall "wxImage_ScaleEx" wxImage_ScaleEx :: Ptr (TImage a) -> CInt -> 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: (@imageSetType obj wxtype@).
imageSetType :: Image  a -> Int ->  IO ()
imageSetType _obj wxtype 
  = withObjectRef "imageSetType" _obj $ \cobj__obj -> 
    wxImage_SetType cobj__obj  (toCInt wxtype)  
foreign import ccall "wxImage_SetType" wxImage_SetType :: Ptr (TImage a) -> CInt -> 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

-- | usage: (@intPropertyCreate label name value@).
intPropertyCreate :: String -> String -> Int ->  IO (IntProperty  ())
intPropertyCreate label name value 
  = withObjectResult $
    withStringPtr label $ \cobj_label -> 
    withStringPtr name $ \cobj_name -> 
    wxIntProperty_Create cobj_label  cobj_name  (toCInt value)  
foreign import ccall "wxIntProperty_Create" wxIntProperty_Create :: Ptr (TWxString a) -> Ptr (TWxString b) -> CInt -> IO (Ptr (TIntProperty ()))

{- |  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: (@listCtrlGetItemFont obj item@).
listCtrlGetItemFont :: ListCtrl  a -> Int ->  IO (Font  ())
listCtrlGetItemFont _obj item 
  = withManagedFontResult $
    withObjectRef "listCtrlGetItemFont" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemFont cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_GetItemFont" wxListCtrl_GetItemFont :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TFont ()))

-- | 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: (@listCtrlIsVirtual obj@).
listCtrlIsVirtual :: ListCtrl  a ->  IO Bool
listCtrlIsVirtual _obj 
  = withBoolResult $
    withObjectRef "listCtrlIsVirtual" _obj $ \cobj__obj -> 
    wxListCtrl_IsVirtual cobj__obj  
foreign import ccall "wxListCtrl_IsVirtual" wxListCtrl_IsVirtual :: Ptr (TListCtrl a) -> IO CBool

-- | usage: (@listCtrlRefreshItem obj item@).
listCtrlRefreshItem :: ListCtrl  a -> Int ->  IO ()
listCtrlRefreshItem _obj item 
  = withObjectRef "listCtrlRefreshItem" _obj $ \cobj__obj -> 
    wxListCtrl_RefreshItem cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_RefreshItem" wxListCtrl_RefreshItem :: Ptr (TListCtrl a) -> CInt -> IO ()

-- | 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

-- | usage: (@listCtrlSortItems2 obj closure@).
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: (@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 ()))