{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE ViewPatterns #-}
module DearImGui.Raw
(
Context(..)
, createContext
, destroyContext
, getCurrentContext
, setCurrentContext
, newFrame
, endFrame
, render
, DrawData(..)
, getDrawData
, checkVersion
, showDemoWindow
, showMetricsWindow
, showDebugLogWindow
, showIDStackToolWindow
, showAboutWindow
, showStyleSelector
, showFontSelector
, showUserGuide
, getVersion
, logButtons
, logText
, styleColorsDark
, styleColorsLight
, styleColorsClassic
, begin
, end
, getWindowDrawList
, getWindowPos
, getWindowSize
, getWindowWidth
, getWindowHeight
, isWindowAppearing
, isWindowCollapsed
, isWindowFocused
, setNextWindowPos
, setNextWindowSize
, setNextWindowFullscreen
, setNextWindowContentSize
, setNextWindowSizeConstraints
, setNextWindowCollapsed
, setNextWindowFocus
, setNextWindowScroll
, setNextWindowBgAlpha
, getContentRegionAvail
, getContentRegionMax
, getWindowContentRegionMin
, getWindowContentRegionMax
, beginDisabled
, endDisabled
, setItemDefaultFocus
, setKeyboardFocusHere
, setNextItemAllowOverlap
, beginChild
, beginChildContext
, endChild
, pushStyleColor
, popStyleColor
, pushStyleVar
, popStyleVar
, pushTabStop
, popTabStop
, separator
, sameLine
, newLine
, spacing
, dummy
, indent
, unindent
, setNextItemWidth
, pushItemWidth
, popItemWidth
, calcItemWidth
, pushTextWrapPos
, popTextWrapPos
, beginGroup
, endGroup
, getCursorPos
, getCursorPosX
, getCursorPosY
, getCursorScreenPos
, getCursorStartPos
, setCursorPos
, setCursorPosX
, setCursorPosY
, setCursorScreenPos
, alignTextToFramePadding
, getTextLineHeight
, getTextLineHeightWithSpacing
, getFrameHeight
, getFrameHeightWithSpacing
, textUnformatted
, textColored
, textDisabled
, textWrapped
, labelText
, bulletText
, separatorText
, valueBool
, valueInt
, valueUInt
, valueFloat
, button
, smallButton
, invisibleButton
, arrowButton
, image
, imageButton
, checkbox
, checkboxFlags
, checkboxFlagsU
, radioButton
, radioButtonI
, progressBar
, bullet
, beginCombo
, endCombo
, combo
, dragFloat
, dragFloat2
, dragFloat3
, dragFloat4
, dragFloatRange2
, dragInt
, dragInt2
, dragInt3
, dragInt4
, dragIntRange2
, dragScalar
, dragScalarN
, sliderFloat
, sliderFloat2
, sliderFloat3
, sliderFloat4
, sliderAngle
, sliderInt
, sliderInt2
, sliderInt3
, sliderInt4
, sliderScalar
, sliderScalarN
, vSliderFloat
, vSliderInt
, vSliderScalar
, inputText
, inputTextMultiline
, inputTextWithHint
, inputFloat
, inputFloat2
, inputFloat3
, inputFloat4
, inputInt
, inputInt2
, inputInt3
, inputInt4
, inputDouble
, inputScalar
, inputScalarN
, colorEdit3
, colorEdit4
, colorPicker3
, colorPicker4
, colorButton
, setColorEditOptions
, beginTable
, endTable
, tableNextRow
, tableNextColumn
, tableSetColumnIndex
, tableSetupColumn
, tableSetupScrollFreeze
, tableHeadersRow
, tableHeader
, tableGetSortSpecs
, tableClearSortSpecsDirty
, tableGetColumnCount
, tableGetColumnIndex
, tableGetRowIndex
, tableGetColumnName
, tableGetColumnFlags
, tableSetColumnEnabled
, tableSetBgColor
, treeNode
, treePush
, treePop
, getTreeNodeToLabelSpacing
, collapsingHeader
, setNextItemOpen
, selectable
, listBox
, plotLines
, plotHistogram
, beginMenuBar
, endMenuBar
, beginMainMenuBar
, endMainMenuBar
, beginMenu
, endMenu
, menuItem
, beginTabBar
, endTabBar
, beginTabItem
, endTabItem
, tabItemButton
, setTabItemClosed
, setItemTooltip
, beginItemTooltip
, beginTooltip
, endTooltip
, beginPopup
, beginPopupModal
, endPopup
, openPopup
, openPopupOnItemClick
, closeCurrentPopup
, beginPopupContextItem
, beginPopupContextWindow
, beginPopupContextVoid
, isPopupOpen
, pushIDInt
, pushIDPtr
, pushIDStr
, pushIDStrLen
, popID
, isItemHovered
, isItemActive
, isItemFocused
, isItemClicked
, isItemVisible
, isItemEdited
, isItemActivated
, isItemDeactivated
, isItemDeactivatedAfterEdit
, isItemToggledOpen
, isAnyItemHovered
, isAnyItemActive
, isAnyItemFocused
, getItemID
, getItemRectMin
, getItemRectMax
, getItemRectSize
, wantCaptureMouse
, getMousePos
, getMousePosOnOpeningCurrentPopup
, isMouseDragging
, getMouseDragDelta
, resetMouseDragDelta
, wantCaptureKeyboard
, ImGuiKeyChord
, shortcut
, setNextItemShortcut
, getBackgroundDrawList
, getForegroundDrawList
, imCol32
, framerate
, getTime
, getFrameCount
, calcTextSize
, module DearImGui.Enums
, module DearImGui.Structs
)
where
import Control.Monad.IO.Class
( MonadIO, liftIO )
import Foreign
import Foreign.C
import System.IO.Unsafe
( unsafePerformIO )
import DearImGui.Raw.Context
( imguiContext )
import DearImGui.Enums
import DearImGui.Structs
import DearImGui.Raw.DrawList (DrawList(..))
import qualified Language.C.Inline as C
import qualified Language.C.Inline.Cpp as Cpp
C.context (Cpp.cppCtx <> C.bsCtx <> imguiContext)
C.include "imgui.h"
Cpp.using "namespace ImGui"
newtype Context = Context (Ptr ImGuiContext)
createContext :: (MonadIO m) => m Context
createContext :: forall (m :: * -> *). MonadIO m => m Context
createContext = IO Context -> m Context
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImGuiContext -> Context
Context (Ptr ImGuiContext -> Context)
-> IO (Ptr ImGuiContext) -> IO Context
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ImGuiContext)
[C.exp| ImGuiContext* { CreateContext() } |]
destroyContext :: (MonadIO m) => Context -> m ()
destroyContext :: forall (m :: * -> *). MonadIO m => Context -> m ()
destroyContext (Context Ptr ImGuiContext
contextPtr) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { DestroyContext($(ImGuiContext* contextPtr)); } |]
getCurrentContext :: MonadIO m => m Context
getCurrentContext :: forall (m :: * -> *). MonadIO m => m Context
getCurrentContext = IO Context -> m Context
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImGuiContext -> Context
Context (Ptr ImGuiContext -> Context)
-> IO (Ptr ImGuiContext) -> IO Context
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ImGuiContext)
[C.exp| ImGuiContext* { GetCurrentContext() } |]
setCurrentContext :: MonadIO m => Context -> m ()
setCurrentContext :: forall (m :: * -> *). MonadIO m => Context -> m ()
setCurrentContext (Context Ptr ImGuiContext
contextPtr) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCurrentContext($(ImGuiContext* contextPtr)) } |]
newFrame :: (MonadIO m) => m ()
newFrame :: forall (m :: * -> *). MonadIO m => m ()
newFrame = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { NewFrame(); } |]
endFrame :: (MonadIO m) => m ()
endFrame :: forall (m :: * -> *). MonadIO m => m ()
endFrame = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndFrame(); } |]
render :: (MonadIO m) => m ()
render :: forall (m :: * -> *). MonadIO m => m ()
render = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { Render(); } |]
newtype DrawData = DrawData (Ptr ())
getDrawData :: (MonadIO m) => m DrawData
getDrawData :: forall (m :: * -> *). MonadIO m => m DrawData
getDrawData = IO DrawData -> m DrawData
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr () -> DrawData
DrawData (Ptr () -> DrawData) -> IO (Ptr ()) -> IO DrawData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ())
[C.exp| void* { GetDrawData() } |]
checkVersion :: (MonadIO m) => m ()
checkVersion :: forall (m :: * -> *). MonadIO m => m ()
checkVersion = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { IMGUI_CHECKVERSION(); } |]
showDemoWindow :: (MonadIO m) => m ()
showDemoWindow :: forall (m :: * -> *). MonadIO m => m ()
showDemoWindow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowDemoWindow(); } |]
showMetricsWindow :: (MonadIO m) => m ()
showMetricsWindow :: forall (m :: * -> *). MonadIO m => m ()
showMetricsWindow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowMetricsWindow(); } |]
showDebugLogWindow :: (MonadIO m) => m ()
showDebugLogWindow :: forall (m :: * -> *). MonadIO m => m ()
showDebugLogWindow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowDebugLogWindow(); } |]
showIDStackToolWindow :: (MonadIO m) => m ()
showIDStackToolWindow :: forall (m :: * -> *). MonadIO m => m ()
showIDStackToolWindow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowIDStackToolWindow(); } |]
showAboutWindow :: (MonadIO m) => m ()
showAboutWindow :: forall (m :: * -> *). MonadIO m => m ()
showAboutWindow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowAboutWindow(); } |]
showStyleSelector :: (MonadIO m) => CString -> m Bool
showStyleSelector :: forall (m :: * -> *). MonadIO m => CString -> m Bool
showStyleSelector CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
ShowStyleSelector(
$(char* labelPtr)
)
}
|]
showFontSelector :: (MonadIO m) => CString -> m ()
showFontSelector :: forall (m :: * -> *). MonadIO m => CString -> m ()
showFontSelector CString
labelPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp|
void {
ShowFontSelector(
$(char* labelPtr)
)
}
|]
showUserGuide :: (MonadIO m) => m ()
showUserGuide :: forall (m :: * -> *). MonadIO m => m ()
showUserGuide = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { ShowUserGuide() } |]
getVersion :: (MonadIO m) => m CString
getVersion :: forall (m :: * -> *). MonadIO m => m CString
getVersion = IO CString -> m CString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CString
[C.exp| const char* { GetVersion() } |]
logButtons :: (MonadIO m) => m ()
logButtons :: forall (m :: * -> *). MonadIO m => m ()
logButtons = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.block| void { LogButtons(); } |]
logText :: (MonadIO m) => CString -> m ()
logText :: forall (m :: * -> *). MonadIO m => CString -> m ()
logText CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { LogText("%s", $(char* textPtr) ); }|]
styleColorsDark :: (MonadIO m) => m ()
styleColorsDark :: forall (m :: * -> *). MonadIO m => m ()
styleColorsDark = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { StyleColorsDark(); } |]
styleColorsLight :: (MonadIO m) => m ()
styleColorsLight :: forall (m :: * -> *). MonadIO m => m ()
styleColorsLight = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { StyleColorsLight(); } |]
styleColorsClassic :: (MonadIO m) => m ()
styleColorsClassic :: forall (m :: * -> *). MonadIO m => m ()
styleColorsClassic = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { StyleColorsClassic(); } |]
begin :: (MonadIO m) => CString -> Maybe (Ptr CBool) -> Maybe (ImGuiWindowFlags) -> m Bool
begin :: forall (m :: * -> *).
MonadIO m =>
CString -> Maybe (Ptr CBool) -> Maybe ImGuiWindowFlags -> m Bool
begin CString
namePtr (Just Ptr CBool
openPtr) (Just ImGuiWindowFlags
flags) = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Begin($(char* namePtr), $(bool* openPtr), $(ImGuiWindowFlags flags)) } |]
begin CString
namePtr (Just Ptr CBool
openPtr) Maybe ImGuiWindowFlags
Nothing = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Begin($(char* namePtr), $(bool* openPtr)) } |]
begin CString
namePtr Maybe (Ptr CBool)
Nothing Maybe ImGuiWindowFlags
Nothing = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Begin($(char* namePtr)) } |]
begin CString
_ Maybe (Ptr CBool)
Nothing Maybe ImGuiWindowFlags
_ = [Char] -> m Bool
forall a. HasCallStack => [Char] -> a
error [Char]
"C++ default argument restriction."
end :: (MonadIO m) => m ()
end :: forall (m :: * -> *). MonadIO m => m ()
end = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { End(); } |]
beginChild :: (MonadIO m) => CString -> Ptr ImVec2 -> CBool -> ImGuiWindowFlags -> m Bool
beginChild :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr ImVec2 -> CBool -> ImGuiWindowFlags -> m Bool
beginChild CString
namePtr Ptr ImVec2
sizePtr CBool
border ImGuiWindowFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
BeginChild(
$(char* namePtr),
*$(ImVec2* sizePtr),
$(bool border),
$(ImGuiWindowFlags flags)
)
}
|]
beginChildContext :: (MonadIO m) => CString -> m Bool
beginChildContext :: forall (m :: * -> *). MonadIO m => CString -> m Bool
beginChildContext CString
namePtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
BeginChild(
$(char* namePtr)
)
}
|]
endChild :: (MonadIO m) => m ()
endChild :: forall (m :: * -> *). MonadIO m => m ()
endChild = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndChild(); } |]
isWindowAppearing :: (MonadIO m) => m Bool
isWindowAppearing :: forall (m :: * -> *). MonadIO m => m Bool
isWindowAppearing = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp|
bool {
IsWindowAppearing()
}
|]
isWindowCollapsed :: (MonadIO m) => m Bool
isWindowCollapsed :: forall (m :: * -> *). MonadIO m => m Bool
isWindowCollapsed = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp|
bool {
IsWindowCollapsed()
}
|]
isWindowFocused :: (MonadIO m) => ImGuiFocusedFlags -> m Bool
isWindowFocused :: forall (m :: * -> *). MonadIO m => ImGuiFocusedFlags -> m Bool
isWindowFocused ImGuiFocusedFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
IsWindowFocused($(ImGuiFocusedFlags flags))
}
|]
separator :: (MonadIO m) => m ()
separator :: forall (m :: * -> *). MonadIO m => m ()
separator = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { Separator(); } |]
sameLine :: (MonadIO m) => m ()
sameLine :: forall (m :: * -> *). MonadIO m => m ()
sameLine = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { SameLine(); } |]
textUnformatted :: (MonadIO m) => CString -> Maybe CString -> m ()
textUnformatted :: forall (m :: * -> *). MonadIO m => CString -> Maybe CString -> m ()
textUnformatted CString
textPtr (Just CString
textEndPtr) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TextUnformatted($(char* textPtr), $(char* textEndPtr)) } |]
textUnformatted CString
textPtr Maybe CString
Nothing = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TextUnformatted($(char* textPtr)) } |]
textColored :: (MonadIO m) => Ptr ImVec4 -> CString -> m ()
textColored :: forall (m :: * -> *). MonadIO m => Ptr ImVec4 -> CString -> m ()
textColored Ptr ImVec4
colorPtr CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TextColored(*$(ImVec4 *colorPtr), "%s", $(char* textPtr)) } |]
textDisabled :: (MonadIO m) => CString -> m ()
textDisabled :: forall (m :: * -> *). MonadIO m => CString -> m ()
textDisabled CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TextDisabled("%s", $(char* textPtr)) } |]
textWrapped :: (MonadIO m) => CString -> m ()
textWrapped :: forall (m :: * -> *). MonadIO m => CString -> m ()
textWrapped CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TextWrapped("%s", $(char* textPtr)) } |]
labelText :: (MonadIO m) => CString -> CString -> m ()
labelText :: forall (m :: * -> *). MonadIO m => CString -> CString -> m ()
labelText CString
labelPtr CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { LabelText($(char* labelPtr), "%s", $(char* textPtr)) } |]
bulletText :: (MonadIO m) => CString -> m ()
bulletText :: forall (m :: * -> *). MonadIO m => CString -> m ()
bulletText CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { BulletText("%s", $(char* textPtr)) } |]
separatorText :: (MonadIO m) => CString -> m ()
separatorText :: forall (m :: * -> *). MonadIO m => CString -> m ()
separatorText CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { SeparatorText($(char* textPtr)); } |]
valueBool :: (MonadIO m) => CString -> CBool -> m ()
valueBool :: forall (m :: * -> *). MonadIO m => CString -> CBool -> m ()
valueBool CString
labelPtr CBool
b = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { Value($(char* labelPtr), $(bool b)); } |]
valueInt :: (MonadIO m) => CString -> CInt -> m ()
valueInt :: forall (m :: * -> *). MonadIO m => CString -> CInt -> m ()
valueInt CString
labelPtr CInt
v = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { Value($(char* labelPtr), $(int v)); } |]
valueUInt :: (MonadIO m) => CString -> CUInt -> m ()
valueUInt :: forall (m :: * -> *). MonadIO m => CString -> CUInt -> m ()
valueUInt CString
labelPtr CUInt
v = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { Value($(char* labelPtr), $(unsigned int v)); } |]
valueFloat :: (MonadIO m) => CString -> CFloat -> CString -> m ()
valueFloat :: forall (m :: * -> *).
MonadIO m =>
CString -> CFloat -> CString -> m ()
valueFloat CString
labelPtr CFloat
v CString
formatPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { Value($(char* labelPtr), $(float v), $(char* formatPtr)); } |]
button :: (MonadIO m) => CString -> m Bool
button :: forall (m :: * -> *). MonadIO m => CString -> m Bool
button CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Button($(char* labelPtr)) } |]
smallButton :: (MonadIO m) => CString -> m Bool
smallButton :: forall (m :: * -> *). MonadIO m => CString -> m Bool
smallButton CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { SmallButton($(char* labelPtr)) } |]
invisibleButton :: (MonadIO m) => CString -> Ptr ImVec2 -> ImGuiButtonFlags -> m Bool
invisibleButton :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr ImVec2 -> ImGuiButtonFlags -> m Bool
invisibleButton CString
labelPtr Ptr ImVec2
size ImGuiButtonFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
InvisibleButton(
$(char* labelPtr),
*$(ImVec2* size),
$(ImGuiButtonFlags flags)
)
}
|]
arrowButton :: (MonadIO m) => CString -> ImGuiDir -> m Bool
arrowButton :: forall (m :: * -> *). MonadIO m => CString -> ImGuiDir -> m Bool
arrowButton CString
strIdPtr ImGuiDir
dir = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ArrowButton($(char* strIdPtr), $(ImGuiDir dir)) } |]
image :: (MonadIO m) => Ptr () -> Ptr ImVec2 -> Ptr ImVec2 -> Ptr ImVec2 -> Ptr ImVec4 -> Ptr ImVec4 -> m ()
image :: forall (m :: * -> *).
MonadIO m =>
Ptr ()
-> Ptr ImVec2
-> Ptr ImVec2
-> Ptr ImVec2
-> Ptr ImVec4
-> Ptr ImVec4
-> m ()
image Ptr ()
userTextureIDPtr Ptr ImVec2
sizePtr Ptr ImVec2
uv0Ptr Ptr ImVec2
uv1Ptr Ptr ImVec4
tintColPtr Ptr ImVec4
borderColPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp|
void {
Image(
$(void* userTextureIDPtr),
*$(ImVec2* sizePtr),
*$(ImVec2* uv0Ptr),
*$(ImVec2* uv1Ptr),
*$(ImVec4* tintColPtr),
*$(ImVec4* borderColPtr)
)
}
|]
imageButton :: (MonadIO m) => Ptr () -> Ptr ImVec2 -> Ptr ImVec2 -> Ptr ImVec2 -> CInt -> Ptr ImVec4 -> Ptr ImVec4 -> m Bool
imageButton :: forall (m :: * -> *).
MonadIO m =>
Ptr ()
-> Ptr ImVec2
-> Ptr ImVec2
-> Ptr ImVec2
-> CInt
-> Ptr ImVec4
-> Ptr ImVec4
-> m Bool
imageButton Ptr ()
userTextureIDPtr Ptr ImVec2
sizePtr Ptr ImVec2
uv0Ptr Ptr ImVec2
uv1Ptr CInt
framePadding Ptr ImVec4
bgColPtr Ptr ImVec4
tintColPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
ImageButton(
$(void* userTextureIDPtr),
*$(ImVec2* sizePtr),
*$(ImVec2* uv0Ptr),
*$(ImVec2* uv1Ptr),
$(int framePadding),
*$(ImVec4* bgColPtr),
*$(ImVec4* tintColPtr)
)
}
|]
checkbox :: (MonadIO m) => CString -> Ptr CBool -> m Bool
checkbox :: forall (m :: * -> *). MonadIO m => CString -> Ptr CBool -> m Bool
checkbox CString
labelPtr Ptr CBool
boolPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Checkbox($(char* labelPtr), $(bool* boolPtr)) } |]
checkboxFlags :: (MonadIO m) => CString -> Ptr CInt -> CInt -> m Bool
checkboxFlags :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> CInt -> m Bool
checkboxFlags CString
labelPtr Ptr CInt
flagsPtr CInt
flagsValue = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { CheckboxFlags($(char* labelPtr), $(int* flagsPtr), $(int flagsValue)) } |]
checkboxFlagsU :: (MonadIO m) => CString -> Ptr CUInt -> CUInt -> m Bool
checkboxFlagsU :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CUInt -> CUInt -> m Bool
checkboxFlagsU CString
labelPtr Ptr CUInt
flagsPtr CUInt
flagsValue = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { CheckboxFlags($(char* labelPtr), $(unsigned int* flagsPtr), $(unsigned int flagsValue)) } |]
radioButton :: (MonadIO m) => CString -> CBool -> m Bool
radioButton :: forall (m :: * -> *). MonadIO m => CString -> CBool -> m Bool
radioButton CString
labelPtr CBool
active = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { RadioButton($(char* labelPtr), $(bool active)) } |]
radioButtonI :: (MonadIO m) => CString -> Ptr CInt -> CInt -> m Bool
radioButtonI :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> CInt -> m Bool
radioButtonI CString
labelPtr Ptr CInt
v CInt
vButton = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { RadioButton($(char* labelPtr), $(int* v), $(int vButton)) } |]
progressBar :: (MonadIO m) => CFloat -> CString -> m ()
progressBar :: forall (m :: * -> *). MonadIO m => CFloat -> CString -> m ()
progressBar CFloat
progress CString
overlayPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { ProgressBar($(float progress), ImVec2(-FLT_MIN, 0), $(char* overlayPtr)) } |]
bullet :: (MonadIO m) => m ()
bullet :: forall (m :: * -> *). MonadIO m => m ()
bullet = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { Bullet() } |]
beginCombo :: (MonadIO m) => CString -> CString -> m Bool
beginCombo :: forall (m :: * -> *). MonadIO m => CString -> CString -> m Bool
beginCombo CString
labelPtr CString
previewValuePtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginCombo($(char* labelPtr), $(char* previewValuePtr)) } |]
endCombo :: (MonadIO m) => m ()
endCombo :: forall (m :: * -> *). MonadIO m => m ()
endCombo = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndCombo() } |]
combo :: (MonadIO m) => CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
combo :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
combo CString
labelPtr Ptr CInt
iPtr Ptr CString
itemsPtr CInt
itemsLen = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Combo($(char* labelPtr), $(int* iPtr), $(char** itemsPtr), $(int itemsLen)) }|]
dragFloat :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { DragFloat( $(char* descPtr), $(float* floatPtr), $(float speed), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
dragFloat2 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat2 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat2 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { DragFloat2( $(char* descPtr), $(float* floatPtr), $(float speed), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
dragFloat3 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat3 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat3 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { DragFloat3( $(char* descPtr), $(float* floatPtr), $(float speed), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
dragFloat4 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat4 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
dragFloat4 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { DragFloat4( $(char* descPtr), $(float* floatPtr), $(float speed), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
dragFloatRange2 :: (MonadIO m) => CString -> Ptr CFloat -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> CString -> ImGuiSliderFlags -> m Bool
dragFloatRange2 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat
-> Ptr CFloat
-> CFloat
-> CFloat
-> CFloat
-> CString
-> CString
-> ImGuiSliderFlags
-> m Bool
dragFloatRange2 CString
labelPtr Ptr CFloat
vCurrentMin Ptr CFloat
vCurrentMax CFloat
vSpeed CFloat
vMin CFloat
vMax CString
formatMin CString
formatMax ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragFloatRange2(
$(char* labelPtr),
$(float* vCurrentMin),
$(float* vCurrentMax),
$(float vSpeed),
$(float vMin),
$(float vMax),
$(char* formatMin),
$(char* formatMax),
$(ImGuiSliderFlags flags)
)
} |]
dragInt :: (MonadIO m) => CString -> Ptr CInt -> CFloat -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
dragInt :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
dragInt CString
labelPtr Ptr CInt
vPtr CFloat
vSpeed CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragInt(
$(char* labelPtr),
$(int* vPtr),
$(float vSpeed),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
dragInt2 :: (MonadIO m) => CString -> Ptr CInt -> CFloat -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
dragInt2 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
dragInt2 CString
labelPtr Ptr CInt
vPtr CFloat
vSpeed CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragInt2(
$(char* labelPtr),
$(int vPtr[2]),
$(float vSpeed),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
dragInt3 :: (MonadIO m) => CString -> Ptr CInt -> CFloat -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
dragInt3 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
dragInt3 CString
labelPtr Ptr CInt
vPtr CFloat
vSpeed CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragInt3(
$(char* labelPtr),
$(int vPtr[3]),
$(float vSpeed),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
dragInt4 :: (MonadIO m) => CString -> Ptr CInt -> CFloat -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
dragInt4 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
dragInt4 CString
labelPtr Ptr CInt
vPtr CFloat
vSpeed CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragInt4(
$(char* labelPtr),
$(int vPtr[4]),
$(float vSpeed),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
dragIntRange2 :: (MonadIO m) => CString -> Ptr CInt -> Ptr CInt -> CFloat -> CInt -> CInt -> CString -> CString -> ImGuiSliderFlags -> m Bool
dragIntRange2 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> CString
-> ImGuiSliderFlags
-> m Bool
dragIntRange2 CString
labelPtr Ptr CInt
vCurrentMin Ptr CInt
vCurrentMax CFloat
vSpeed CInt
vMin CInt
vMax CString
formatMin CString
formatMax ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragIntRange2(
$(char* labelPtr),
$(int* vCurrentMin),
$(int* vCurrentMax),
$(float vSpeed),
$(int vMin),
$(int vMax),
$(char* formatMin),
$(char* formatMax),
$(ImGuiSliderFlags flags)
)
} |]
dragScalar :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> CFloat -> Ptr a -> Ptr a -> CString -> ImGuiSliderFlags -> m Bool
dragScalar :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CFloat
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
dragScalar CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr CFloat
vSpeed Ptr a
minPtr Ptr a
maxPtr CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragScalar(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(float vSpeed),
$(void* minPtr_),
$(void* maxPtr_),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
minPtr_ :: Ptr b
minPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
minPtr
maxPtr_ :: Ptr b
maxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
maxPtr
dragScalarN :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> CInt -> CFloat -> Ptr a -> Ptr a -> CString -> ImGuiSliderFlags -> m Bool
dragScalarN :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CInt
-> CFloat
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
dragScalarN CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr CInt
components CFloat
vSpeed Ptr a
minPtr Ptr a
maxPtr CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
DragScalarN(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(int components),
$(float vSpeed),
$(void* minPtr_),
$(void* maxPtr_),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
minPtr_ :: Ptr b
minPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
minPtr
maxPtr_ :: Ptr b
maxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
maxPtr
sliderFloat :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { SliderFloat( $(char* descPtr), $(float* floatPtr), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
sliderFloat2 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat2 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat2 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { SliderFloat2( $(char* descPtr), $(float* floatPtr), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
sliderFloat3 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat3 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { SliderFloat3( $(char* descPtr), $(float* floatPtr), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
sliderFloat4 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
sliderFloat4 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue CString
formatPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { SliderFloat4( $(char* descPtr), $(float* floatPtr), $(float minValue), $(float maxValue), $(char* formatPtr)) } |]
sliderAngle :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> ImGuiSliderFlags -> m Bool
sliderAngle :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat
-> CFloat
-> CFloat
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderAngle CString
descPtr Ptr CFloat
valueRadPtr CFloat
degreesMin CFloat
degreesMax CString
format ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderAngle(
$(char* descPtr),
$(float* valueRadPtr),
$(float degreesMin),
$(float degreesMax),
$(char* format),
$(ImGuiSliderFlags flags)
)
} |]
sliderInt :: (MonadIO m) => CString -> Ptr CInt -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
sliderInt :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderInt CString
labelPtr Ptr CInt
vPtr CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderInt(
$(char* labelPtr),
$(int* vPtr),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
sliderInt2 :: (MonadIO m) => CString -> Ptr CInt -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
sliderInt2 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderInt2 CString
labelPtr Ptr CInt
vPtr CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderInt2(
$(char* labelPtr),
$(int vPtr[2]),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
sliderInt3 :: (MonadIO m) => CString -> Ptr CInt -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
sliderInt3 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderInt3 CString
labelPtr Ptr CInt
vPtr CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderInt3(
$(char* labelPtr),
$(int vPtr[3]),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
sliderInt4 :: (MonadIO m) => CString -> Ptr CInt -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
sliderInt4 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderInt4 CString
labelPtr Ptr CInt
vPtr CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderInt4(
$(char* labelPtr),
$(int vPtr[4]),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
sliderScalar :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> Ptr a -> Ptr a -> CString -> ImGuiSliderFlags -> m Bool
sliderScalar :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderScalar CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr Ptr a
minPtr Ptr a
maxPtr CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderScalar(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(void* minPtr_),
$(void* maxPtr_),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
minPtr_ :: Ptr b
minPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
minPtr
maxPtr_ :: Ptr b
maxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
maxPtr
sliderScalarN :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> CInt -> Ptr a -> Ptr a -> CString -> ImGuiSliderFlags -> m Bool
sliderScalarN :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CInt
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
sliderScalarN CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr CInt
components Ptr a
minPtr Ptr a
maxPtr CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
SliderScalarN(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(int components),
$(void* minPtr_),
$(void* maxPtr_),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
minPtr_ :: Ptr b
minPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
minPtr
maxPtr_ :: Ptr b
maxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
maxPtr
vSliderFloat :: (MonadIO m) => CString -> Ptr ImVec2 -> Ptr CFloat -> CFloat -> CFloat -> CString -> ImGuiSliderFlags -> m Bool
vSliderFloat :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr ImVec2
-> Ptr CFloat
-> CFloat
-> CFloat
-> CString
-> ImGuiSliderFlags
-> m Bool
vSliderFloat CString
labelPtr Ptr ImVec2
sizePtr Ptr CFloat
vPtr CFloat
vMin CFloat
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
VSliderFloat(
$(char* labelPtr),
*$(ImVec2* sizePtr),
$(float* vPtr),
$(float vMin),
$(float vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
vSliderInt :: (MonadIO m) => CString -> Ptr ImVec2 -> Ptr CInt -> CInt -> CInt -> CString -> ImGuiSliderFlags -> m Bool
vSliderInt :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr ImVec2
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
vSliderInt CString
labelPtr Ptr ImVec2
sizePtr Ptr CInt
vPtr CInt
vMin CInt
vMax CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
VSliderInt(
$(char* labelPtr),
*$(ImVec2* sizePtr),
$(int* vPtr),
$(int vMin),
$(int vMax),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
vSliderScalar :: (MonadIO m) => CString -> Ptr ImVec2 -> ImGuiDataType -> Ptr a -> Ptr a -> Ptr a -> CString -> ImGuiSliderFlags -> m Bool
vSliderScalar :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> Ptr ImVec2
-> ImGuiDataType
-> Ptr a
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
vSliderScalar CString
labelPtr Ptr ImVec2
sizePtr ImGuiDataType
dataType Ptr a
dataPtr Ptr a
minPtr Ptr a
maxPtr CString
formatPtr ImGuiSliderFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
VSliderScalar(
$(char* labelPtr),
*$(ImVec2* sizePtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(void* minPtr_),
$(void* maxPtr_),
$(char* formatPtr),
$(ImGuiSliderFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
minPtr_ :: Ptr b
minPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
minPtr
maxPtr_ :: Ptr b
maxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
maxPtr
inputText :: (MonadIO m) => CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
inputText :: forall (m :: * -> *).
MonadIO m =>
CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
inputText CString
labelPtr (CString
bufPtr, Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CInt
bufSize) ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
InputText(
$(char* labelPtr),
$(char* bufPtr),
$(int bufSize),
$(ImGuiInputTextFlags flags)
)
}
|]
inputTextMultiline :: (MonadIO m) => CString -> CStringLen -> Ptr ImVec2 -> ImGuiInputTextFlags -> m Bool
inputTextMultiline :: forall (m :: * -> *).
MonadIO m =>
CString
-> CStringLen -> Ptr ImVec2 -> ImGuiInputTextFlags -> m Bool
inputTextMultiline CString
labelPtr (CString
bufPtr, Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CSize
bufSize) Ptr ImVec2
sizePtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
InputTextMultiline(
$(char* labelPtr),
$(char* bufPtr),
$(size_t bufSize),
*$(ImVec2* sizePtr),
$(ImGuiInputTextFlags flags)
)
}
|]
inputTextWithHint :: (MonadIO m) => CString -> CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
inputTextWithHint :: forall (m :: * -> *).
MonadIO m =>
CString -> CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
inputTextWithHint CString
labelPtr CString
hintPtr (CString
bufPtr, Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral -> CInt
bufSize) ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp|
bool {
InputTextWithHint(
$(char* labelPtr),
$(char* hintPtr),
$(char* bufPtr),
$(int bufSize),
$(ImGuiInputTextFlags flags)
)
}
|]
inputFloat :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat
-> CFloat
-> CFloat
-> CString
-> ImGuiInputTextFlags
-> m Bool
inputFloat CString
descPtr Ptr CFloat
floatPtr CFloat
step CFloat
stepFast CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputFloat( $(char* descPtr), $(float* floatPtr), $(float step), $(float stepFast), $(char* formatPtr), $(ImGuiInputTextFlags flags)) } |]
inputFloat2 :: (MonadIO m) => CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat2 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat2 CString
descPtr Ptr CFloat
floatPtr CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputFloat2( $(char* descPtr), $(float* floatPtr), $(char* formatPtr), $(ImGuiInputTextFlags flags)) } |]
inputFloat3 :: (MonadIO m) => CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat3 CString
descPtr Ptr CFloat
floatPtr CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputFloat3( $(char* descPtr), $(float* floatPtr), $(char* formatPtr), $(ImGuiInputTextFlags flags)) } |]
inputFloat4 :: (MonadIO m) => CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CString -> ImGuiInputTextFlags -> m Bool
inputFloat4 CString
descPtr Ptr CFloat
floatPtr CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputFloat4( $(char* descPtr), $(float* floatPtr), $(char* formatPtr), $(ImGuiInputTextFlags flags)) } |]
inputInt :: (MonadIO m) => CString -> Ptr CInt -> CInt -> CInt -> ImGuiInputTextFlags -> m Bool
inputInt :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt -> CInt -> CInt -> ImGuiInputTextFlags -> m Bool
inputInt CString
descPtr Ptr CInt
intPtr CInt
step CInt
stepFast ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputInt( $(char* descPtr), $(int* intPtr), $(int step), $(int stepFast), $(ImGuiInputTextFlags flags)) } |]
inputInt2 :: (MonadIO m) => CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt2 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt2 CString
descPtr Ptr CInt
intPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputInt2( $(char* descPtr), $(int* intPtr), $(ImGuiInputTextFlags flags)) } |]
inputInt3 :: (MonadIO m) => CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt3 CString
descPtr Ptr CInt
intPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputInt3( $(char* descPtr), $(int* intPtr), $(ImGuiInputTextFlags flags)) } |]
inputInt4 :: (MonadIO m) => CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> ImGuiInputTextFlags -> m Bool
inputInt4 CString
descPtr Ptr CInt
intPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputInt4( $(char* descPtr), $(int* intPtr), $(ImGuiInputTextFlags flags)) } |]
inputDouble :: (MonadIO m) => CString -> Ptr CDouble -> CDouble -> CDouble -> CString -> ImGuiInputTextFlags -> m Bool
inputDouble :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CDouble
-> CDouble
-> CDouble
-> CString
-> ImGuiInputTextFlags
-> m Bool
inputDouble CString
descPtr Ptr CDouble
doublePtr CDouble
step CDouble
stepFast CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { InputDouble( $(char* descPtr), $(double* doublePtr), $(double step), $(double stepFast), $(char* formatPtr), $(ImGuiInputTextFlags flags)) } |]
inputScalar :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> Ptr a -> Ptr a -> CString -> ImGuiInputTextFlags -> m Bool
inputScalar :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> Ptr a
-> Ptr a
-> CString
-> ImGuiInputTextFlags
-> m Bool
inputScalar CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr Ptr a
stepPtr Ptr a
stepMaxPtr CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
InputScalar(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(void* stepPtr_),
$(void* stepMaxPtr_),
$(char* formatPtr),
$(ImGuiInputTextFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
stepPtr_ :: Ptr b
stepPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
stepPtr
stepMaxPtr_ :: Ptr b
stepMaxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
stepMaxPtr
inputScalarN :: (MonadIO m) => CString -> ImGuiDataType -> Ptr a -> CInt -> Ptr a -> Ptr a -> CString -> ImGuiInputTextFlags -> m Bool
inputScalarN :: forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CInt
-> Ptr a
-> Ptr a
-> CString
-> ImGuiInputTextFlags
-> m Bool
inputScalarN CString
labelPtr ImGuiDataType
dataType Ptr a
dataPtr CInt
components Ptr a
stepPtr Ptr a
stepMaxPtr CString
formatPtr ImGuiInputTextFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool {
InputScalarN(
$(char* labelPtr),
$(ImGuiDataType dataType),
$(void* dataPtr_),
$(int components),
$(void* stepPtr_),
$(void* stepMaxPtr_),
$(char* formatPtr),
$(ImGuiInputTextFlags flags)
)
} |]
where
dataPtr_ :: Ptr b
dataPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
dataPtr
stepPtr_ :: Ptr b
stepPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
stepPtr
stepMaxPtr_ :: Ptr b
stepMaxPtr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
stepMaxPtr
colorEdit3 :: (MonadIO m) => CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorEdit3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorEdit3 CString
descPtr Ptr CFloat
refPtr ImGuiColorEditFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ColorEdit3( $(char* descPtr), $(float* refPtr), $(ImGuiColorEditFlags flags) ) } |]
colorEdit4 :: (MonadIO m) => CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorEdit4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorEdit4 CString
descPtr Ptr CFloat
refPtr ImGuiColorEditFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ColorEdit4( $(char* descPtr), $(float* refPtr), $(ImGuiColorEditFlags flags) ) } |]
colorPicker3 :: (MonadIO m) => CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorPicker3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> ImGuiColorEditFlags -> m Bool
colorPicker3 CString
descPtr Ptr CFloat
refPtr ImGuiColorEditFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ColorPicker3( $(char* descPtr), $(float* refPtr), $(ImGuiColorEditFlags flags) ) } |]
colorPicker4 :: (MonadIO m) => CString -> Ptr CFloat -> ImGuiColorEditFlags -> Ptr CFloat -> m Bool
colorPicker4 :: forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> ImGuiColorEditFlags -> Ptr CFloat -> m Bool
colorPicker4 CString
descPtr Ptr CFloat
refPtr ImGuiColorEditFlags
flags Ptr CFloat
refColPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/= ) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ColorPicker4( $(char* descPtr), $(float* refPtr), $(ImGuiColorEditFlags flags), $(float* refColPtr) ) } |]
setColorEditOptions :: (MonadIO m) => ImGuiColorEditFlags -> m ()
setColorEditOptions :: forall (m :: * -> *). MonadIO m => ImGuiColorEditFlags -> m ()
setColorEditOptions ImGuiColorEditFlags
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { SetColorEditOptions( $(ImGuiColorEditFlags flags) ); } |]
colorButton :: (MonadIO m) => CString -> Ptr ImVec4 -> m Bool
colorButton :: forall (m :: * -> *). MonadIO m => CString -> Ptr ImVec4 -> m Bool
colorButton CString
descPtr Ptr ImVec4
refPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ColorButton( $(char* descPtr), *$(ImVec4* refPtr) ) } |]
beginTable :: MonadIO m => CString -> CInt -> ImGuiTableFlags -> Ptr ImVec2 -> CFloat -> m Bool
beginTable :: forall (m :: * -> *).
MonadIO m =>
CString
-> CInt -> ImGuiTableFlags -> Ptr ImVec2 -> CFloat -> m Bool
beginTable CString
labelPtr CInt
column ImGuiTableFlags
flags Ptr ImVec2
outerSizePtr CFloat
innerWidth = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginTable($(char* labelPtr), $(int column), $(ImGuiTableFlags flags), *$(ImVec2* outerSizePtr), $(float innerWidth)) } |]
endTable :: MonadIO m => m ()
endTable :: forall (m :: * -> *). MonadIO m => m ()
endTable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndTable() } |]
tableNextRow :: MonadIO m => ImGuiTableRowFlags -> CFloat -> m ()
tableNextRow :: forall (m :: * -> *).
MonadIO m =>
ImGuiTableRowFlags -> CFloat -> m ()
tableNextRow ImGuiTableRowFlags
flags CFloat
minRowHeight = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableNextRow($(ImGuiTableRowFlags flags), $(float minRowHeight)) } |]
tableNextColumn :: MonadIO m => m Bool
tableNextColumn :: forall (m :: * -> *). MonadIO m => m Bool
tableNextColumn = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { TableNextColumn() } |]
tableSetColumnIndex :: MonadIO m => CInt -> m Bool
tableSetColumnIndex :: forall (m :: * -> *). MonadIO m => CInt -> m Bool
tableSetColumnIndex CInt
column= IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { TableSetColumnIndex($(int column)) } |]
tableSetupColumn :: MonadIO m => CString -> ImGuiTableColumnFlags -> CFloat -> ImGuiID-> m ()
tableSetupColumn :: forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTableColumnFlags -> CFloat -> ImGuiID -> m ()
tableSetupColumn CString
labelPtr ImGuiTableColumnFlags
flags CFloat
initWidthOrWeight ImGuiID
userId = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableSetupColumn($(char* labelPtr), $(ImGuiTableColumnFlags flags), $(float initWidthOrWeight), $(ImGuiID userId)) } |]
tableSetupScrollFreeze :: MonadIO m => CInt -> CInt -> m ()
tableSetupScrollFreeze :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
tableSetupScrollFreeze CInt
cols CInt
rows = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableSetupScrollFreeze($(int cols), $(int rows)) } |]
tableHeadersRow :: MonadIO m => m ()
= IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { TableHeadersRow() } |]
tableHeader :: MonadIO m => CString -> m ()
CString
labelPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableHeader($(char* labelPtr)) } |]
tableGetSortSpecs :: MonadIO m => m (Maybe (Ptr ImGuiTableSortSpecs))
tableGetSortSpecs :: forall (m :: * -> *).
MonadIO m =>
m (Maybe (Ptr ImGuiTableSortSpecs))
tableGetSortSpecs = IO (Maybe (Ptr ImGuiTableSortSpecs))
-> m (Maybe (Ptr ImGuiTableSortSpecs))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImGuiTableSortSpecs
ptr <- IO (Ptr ImGuiTableSortSpecs)
[C.exp| ImGuiTableSortSpecs* { TableGetSortSpecs() } |]
if Ptr ImGuiTableSortSpecs
ptr Ptr ImGuiTableSortSpecs -> Ptr ImGuiTableSortSpecs -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr ImGuiTableSortSpecs
forall {b}. Ptr b
nullPtr then
Maybe (Ptr ImGuiTableSortSpecs)
-> IO (Maybe (Ptr ImGuiTableSortSpecs))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Ptr ImGuiTableSortSpecs)
forall a. Maybe a
Nothing
else
Maybe (Ptr ImGuiTableSortSpecs)
-> IO (Maybe (Ptr ImGuiTableSortSpecs))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Ptr ImGuiTableSortSpecs)
-> IO (Maybe (Ptr ImGuiTableSortSpecs)))
-> Maybe (Ptr ImGuiTableSortSpecs)
-> IO (Maybe (Ptr ImGuiTableSortSpecs))
forall a b. (a -> b) -> a -> b
$ Ptr ImGuiTableSortSpecs -> Maybe (Ptr ImGuiTableSortSpecs)
forall a. a -> Maybe a
Just Ptr ImGuiTableSortSpecs
ptr
tableClearSortSpecsDirty :: MonadIO m => Ptr ImGuiTableSortSpecs -> m ()
tableClearSortSpecsDirty :: forall (m :: * -> *). MonadIO m => Ptr ImGuiTableSortSpecs -> m ()
tableClearSortSpecsDirty Ptr ImGuiTableSortSpecs
specsPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void {
$(ImGuiTableSortSpecs* specsPtr)->SpecsDirty = false;
} |]
tableGetColumnCount :: MonadIO m => m CInt
tableGetColumnCount :: forall (m :: * -> *). MonadIO m => m CInt
tableGetColumnCount = IO CInt -> m CInt
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CInt
[C.exp| int { TableGetColumnCount() } |]
tableGetColumnIndex :: MonadIO m => m CInt
tableGetColumnIndex :: forall (m :: * -> *). MonadIO m => m CInt
tableGetColumnIndex = IO CInt -> m CInt
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CInt
[C.exp| int { TableGetColumnIndex() } |]
tableGetRowIndex :: MonadIO m => m CInt
tableGetRowIndex :: forall (m :: * -> *). MonadIO m => m CInt
tableGetRowIndex = IO CInt -> m CInt
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CInt
[C.exp| int { TableGetRowIndex() } |]
tableGetColumnName :: MonadIO m => Maybe CInt -> m CString
tableGetColumnName :: forall (m :: * -> *). MonadIO m => Maybe CInt -> m CString
tableGetColumnName Maybe CInt
Nothing = Maybe CInt -> m CString
forall (m :: * -> *). MonadIO m => Maybe CInt -> m CString
tableGetColumnName (CInt -> Maybe CInt
forall a. a -> Maybe a
Just (-CInt
1))
tableGetColumnName (Just CInt
column_n) = IO CString -> m CString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| const char* { TableGetColumnName($(int column_n)) } |]
tableGetColumnFlags :: MonadIO m => Maybe CInt -> m ImGuiTableColumnFlags
tableGetColumnFlags :: forall (m :: * -> *).
MonadIO m =>
Maybe CInt -> m ImGuiTableColumnFlags
tableGetColumnFlags Maybe CInt
Nothing = Maybe CInt -> m ImGuiTableColumnFlags
forall (m :: * -> *).
MonadIO m =>
Maybe CInt -> m ImGuiTableColumnFlags
tableGetColumnFlags (CInt -> Maybe CInt
forall a. a -> Maybe a
Just (-CInt
1))
tableGetColumnFlags (Just CInt
column_n) = IO ImGuiTableColumnFlags -> m ImGuiTableColumnFlags
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| ImGuiTableColumnFlags { TableGetColumnFlags($(int column_n)) } |]
tableSetColumnEnabled :: MonadIO m => CInt -> CBool -> m ()
tableSetColumnEnabled :: forall (m :: * -> *). MonadIO m => CInt -> CBool -> m ()
tableSetColumnEnabled CInt
column_n CBool
v = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableSetColumnEnabled($(int column_n), $(bool v)) } |]
tableSetBgColor :: MonadIO m => ImGuiTableBgTarget -> ImU32 -> Maybe CInt -> m ()
tableSetBgColor :: forall (m :: * -> *).
MonadIO m =>
ImGuiTableBgTarget -> ImGuiID -> Maybe CInt -> m ()
tableSetBgColor ImGuiTableBgTarget
target ImGuiID
color Maybe CInt
Nothing = ImGuiTableBgTarget -> ImGuiID -> Maybe CInt -> m ()
forall (m :: * -> *).
MonadIO m =>
ImGuiTableBgTarget -> ImGuiID -> Maybe CInt -> m ()
tableSetBgColor ImGuiTableBgTarget
target ImGuiID
color (CInt -> Maybe CInt
forall a. a -> Maybe a
Just (-CInt
1))
tableSetBgColor ImGuiTableBgTarget
target ImGuiID
color (Just CInt
column_n) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableSetBgColor($(ImGuiTableBgTarget target), $(ImU32 color), $(int column_n)) } |]
treeNode :: (MonadIO m) => CString -> m Bool
treeNode :: forall (m :: * -> *). MonadIO m => CString -> m Bool
treeNode CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { TreeNode($(char* labelPtr)) } |]
treePush :: (MonadIO m) => CString -> m ()
treePush :: forall (m :: * -> *). MonadIO m => CString -> m ()
treePush CString
labelPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TreePush($(char* labelPtr)) } |]
treePop :: (MonadIO m) => m ()
treePop :: forall (m :: * -> *). MonadIO m => m ()
treePop = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { TreePop() } |]
getTreeNodeToLabelSpacing :: (MonadIO m) => m CFloat
getTreeNodeToLabelSpacing :: forall (m :: * -> *). MonadIO m => m CFloat
getTreeNodeToLabelSpacing = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetTreeNodeToLabelSpacing() } |]
collapsingHeader :: (MonadIO m) => CString -> Ptr CBool -> ImGuiTreeNodeFlags -> m Bool
CString
labelPtr Ptr CBool
visiblePtr ImGuiTreeNodeFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { CollapsingHeader($(char* labelPtr), $(bool* visiblePtr), $(ImGuiTreeNodeFlags flags)) } |]
setNextItemOpen :: (MonadIO m) => CBool -> m ()
setNextItemOpen :: forall (m :: * -> *). MonadIO m => CBool -> m ()
setNextItemOpen CBool
is_open = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextItemOpen($(bool is_open)) } |]
selectable :: (MonadIO m) => CString -> CBool -> ImGuiSelectableFlags -> Ptr ImVec2 -> m Bool
selectable :: forall (m :: * -> *).
MonadIO m =>
CString -> CBool -> ImGuiSelectableFlags -> Ptr ImVec2 -> m Bool
selectable CString
labelPtr CBool
selected ImGuiSelectableFlags
flags Ptr ImVec2
size = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Selectable($(char* labelPtr), $(bool selected), $(ImGuiSelectableFlags flags), *$(ImVec2 *size)) } |]
listBox :: (MonadIO m) => CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
listBox :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
listBox CString
labelPtr Ptr CInt
iPtr Ptr CString
itemsPtr CInt
itemsLen = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { ListBox($(char* labelPtr), $(int* iPtr), $(char** itemsPtr), $(int itemsLen)) }|]
plotLines :: (MonadIO m) => CString -> Ptr CFloat -> CInt -> m ()
plotLines :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CInt -> m ()
plotLines CString
labelPtr Ptr CFloat
valuesPtr CInt
valuesLen = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PlotLines($(char* labelPtr), $(float* valuesPtr), $(int valuesLen)) } |]
plotHistogram :: (MonadIO m) => CString -> Ptr CFloat -> CInt -> m ()
plotHistogram :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CInt -> m ()
plotHistogram CString
labelPtr Ptr CFloat
valuesPtr CInt
valuesLen = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PlotHistogram($(char* labelPtr), $(float* valuesPtr), $(int valuesLen)) } |]
beginMenuBar :: (MonadIO m) => m Bool
= IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { BeginMenuBar() } |]
endMenuBar :: (MonadIO m) => m ()
= IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndMenuBar(); } |]
beginMainMenuBar :: (MonadIO m) => m Bool
beginMainMenuBar :: forall (m :: * -> *). MonadIO m => m Bool
beginMainMenuBar = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { BeginMainMenuBar() } |]
endMainMenuBar :: (MonadIO m) => m ()
endMainMenuBar :: forall (m :: * -> *). MonadIO m => m ()
endMainMenuBar = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndMainMenuBar(); } |]
beginMenu :: (MonadIO m) => CString -> m Bool
CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginMenu($(char* labelPtr)) } |]
endMenu :: (MonadIO m) => m ()
= IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndMenu(); } |]
menuItem :: (MonadIO m) => CString -> m Bool
CString
labelPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { MenuItem($(char* labelPtr)) } |]
beginTabBar :: (MonadIO m) => CString -> ImGuiTabBarFlags -> m Bool
beginTabBar :: forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTabBarFlags -> m Bool
beginTabBar CString
tabBarID ImGuiTabBarFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginTabBar($(char* tabBarID), $(ImGuiTabBarFlags flags) ) } |]
endTabBar :: (MonadIO m) => m ()
endTabBar :: forall (m :: * -> *). MonadIO m => m ()
endTabBar = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndTabBar(); } |]
beginTabItem :: (MonadIO m) => CString -> Ptr CBool -> ImGuiTabItemFlags -> m Bool
beginTabItem :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CBool -> ImGuiTabItemFlags -> m Bool
beginTabItem CString
namePtr Ptr CBool
refPtr ImGuiTabItemFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginTabItem($(char* namePtr), $(bool* refPtr), $(ImGuiTabItemFlags flags) ) } |]
endTabItem :: (MonadIO m) => m ()
endTabItem :: forall (m :: * -> *). MonadIO m => m ()
endTabItem = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndTabItem(); } |]
tabItemButton :: (MonadIO m) => CString -> ImGuiTabItemFlags -> m Bool
tabItemButton :: forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTabItemFlags -> m Bool
tabItemButton CString
namePtr ImGuiTabItemFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { TabItemButton($(char* namePtr), $(ImGuiTabItemFlags flags) ) } |]
setTabItemClosed :: (MonadIO m) => CString -> m ()
setTabItemClosed :: forall (m :: * -> *). MonadIO m => CString -> m ()
setTabItemClosed CString
namePtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetTabItemClosed($(char* namePtr)); } |]
beginTooltip :: (MonadIO m) => m Bool
beginTooltip :: forall (m :: * -> *). MonadIO m => m Bool
beginTooltip = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { BeginTooltip() } |]
beginItemTooltip :: (MonadIO m) => m Bool
beginItemTooltip :: forall (m :: * -> *). MonadIO m => m Bool
beginItemTooltip = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { BeginItemTooltip() } |]
endTooltip :: (MonadIO m) => m ()
endTooltip :: forall (m :: * -> *). MonadIO m => m ()
endTooltip = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndTooltip() } |]
setItemTooltip :: (MonadIO m) => CString -> m ()
setItemTooltip :: forall (m :: * -> *). MonadIO m => CString -> m ()
setItemTooltip CString
textPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetItemTooltip("%s", $(char* textPtr)); } |]
beginPopup :: (MonadIO m) => CString -> m Bool
CString
popupIdPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginPopup($(char* popupIdPtr)) } |]
beginPopupModal :: (MonadIO m) => CString -> m Bool
CString
popupIdPtr = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginPopupModal($(char* popupIdPtr)) } |]
endPopup :: (MonadIO m) => m ()
= IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndPopup() } |]
openPopup :: (MonadIO m) => CString -> m ()
CString
popupIdPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { OpenPopup($(char* popupIdPtr)) } |]
openPopupOnItemClick :: (MonadIO m) => CString -> ImGuiPopupFlags-> m ()
CString
popupIdPtr ImGuiPopupFlags
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { OpenPopupOnItemClick($(char* popupIdPtr), $(ImGuiPopupFlags flags)) } |]
closeCurrentPopup :: (MonadIO m) => m ()
= IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { CloseCurrentPopup() } |]
beginPopupContextItem :: (MonadIO m) => CString -> ImGuiPopupFlags-> m Bool
CString
popupIdPtr ImGuiPopupFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginPopupContextItem($(char* popupIdPtr), $(ImGuiPopupFlags flags)) } |]
beginPopupContextWindow :: (MonadIO m) => CString -> ImGuiPopupFlags-> m Bool
CString
popupIdPtr ImGuiPopupFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginPopupContextWindow($(char* popupIdPtr), $(ImGuiPopupFlags flags)) } |]
beginPopupContextVoid :: (MonadIO m) => CString -> ImGuiPopupFlags-> m Bool
CString
popupIdPtr ImGuiPopupFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { BeginPopupContextVoid($(char* popupIdPtr), $(ImGuiPopupFlags flags)) } |]
isPopupOpen :: (MonadIO m) => CString -> ImGuiPopupFlags-> m Bool
CString
popupIdPtr ImGuiPopupFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { IsPopupOpen($(char* popupIdPtr), $(ImGuiPopupFlags flags)) } |]
isItemHovered :: (MonadIO m) => m Bool
isItemHovered :: forall (m :: * -> *). MonadIO m => m Bool
isItemHovered = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemHovered() } |]
isItemActive :: (MonadIO m) => m Bool
isItemActive :: forall (m :: * -> *). MonadIO m => m Bool
isItemActive = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemActive() } |]
isItemFocused :: (MonadIO m) => m Bool
isItemFocused :: forall (m :: * -> *). MonadIO m => m Bool
isItemFocused = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemFocused() } |]
isItemClicked :: (MonadIO m) => ImGuiMouseButton -> m Bool
isItemClicked :: forall (m :: * -> *). MonadIO m => ImGuiMouseButton -> m Bool
isItemClicked ImGuiMouseButton
mouseButton = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { IsItemClicked( $(ImGuiMouseButton mouseButton) ) } |]
isItemVisible :: (MonadIO m) => m Bool
isItemVisible :: forall (m :: * -> *). MonadIO m => m Bool
isItemVisible = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemVisible() } |]
isItemEdited :: (MonadIO m) => m Bool
isItemEdited :: forall (m :: * -> *). MonadIO m => m Bool
isItemEdited = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemEdited() } |]
isItemActivated :: (MonadIO m) => m Bool
isItemActivated :: forall (m :: * -> *). MonadIO m => m Bool
isItemActivated = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemActivated() } |]
isItemDeactivated :: (MonadIO m) => m Bool
isItemDeactivated :: forall (m :: * -> *). MonadIO m => m Bool
isItemDeactivated = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemDeactivated() } |]
isItemDeactivatedAfterEdit :: (MonadIO m) => m Bool
isItemDeactivatedAfterEdit :: forall (m :: * -> *). MonadIO m => m Bool
isItemDeactivatedAfterEdit = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemDeactivatedAfterEdit() } |]
isItemToggledOpen :: (MonadIO m) => m Bool
isItemToggledOpen :: forall (m :: * -> *). MonadIO m => m Bool
isItemToggledOpen = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsItemToggledOpen() } |]
isAnyItemHovered :: (MonadIO m) => m Bool
isAnyItemHovered :: forall (m :: * -> *). MonadIO m => m Bool
isAnyItemHovered = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsAnyItemHovered() } |]
isAnyItemActive :: (MonadIO m) => m Bool
isAnyItemActive :: forall (m :: * -> *). MonadIO m => m Bool
isAnyItemActive = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsAnyItemActive() } |]
isAnyItemFocused :: (MonadIO m) => m Bool
isAnyItemFocused :: forall (m :: * -> *). MonadIO m => m Bool
isAnyItemFocused = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { IsAnyItemFocused() } |]
getItemID :: (MonadIO m) => m ImGuiID
getItemID :: forall (m :: * -> *). MonadIO m => m ImGuiID
getItemID = IO ImGuiID -> m ImGuiID
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ImGuiID
[C.exp| ImGuiID { GetItemID() } |]
getItemRectMin :: (MonadIO m) => m ImVec2
getItemRectMin :: forall (m :: * -> *). MonadIO m => m ImVec2
getItemRectMin = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetItemRectMin();
}
|]
getItemRectMax :: (MonadIO m) => m ImVec2
getItemRectMax :: forall (m :: * -> *). MonadIO m => m ImVec2
getItemRectMax = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetItemRectMin();
}
|]
getItemRectSize :: (MonadIO m) => m ImVec2
getItemRectSize :: forall (m :: * -> *). MonadIO m => m ImVec2
getItemRectSize = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetItemRectSize();
}
|]
getWindowDrawList :: (MonadIO m) => m DrawList
getWindowDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getWindowDrawList = IO DrawList -> m DrawList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImDrawList -> DrawList
DrawList (Ptr ImDrawList -> DrawList) -> IO (Ptr ImDrawList) -> IO DrawList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ImDrawList)
[C.exp|
ImDrawList* {
GetWindowDrawList()
}
|]
getWindowPos :: (MonadIO m) => m ImVec2
getWindowPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getWindowPos = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetWindowPos();
}
|]
getWindowSize :: (MonadIO m) => m ImVec2
getWindowSize :: forall (m :: * -> *). MonadIO m => m ImVec2
getWindowSize = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetWindowSize();
}
|]
getWindowWidth :: (MonadIO m) => m CFloat
getWindowWidth :: forall (m :: * -> *). MonadIO m => m CFloat
getWindowWidth = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetWindowWidth() } |]
getWindowHeight :: (MonadIO m) => m CFloat
getWindowHeight :: forall (m :: * -> *). MonadIO m => m CFloat
getWindowHeight = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetWindowHeight() } |]
setNextWindowPos :: (MonadIO m) => Ptr ImVec2 -> ImGuiCond -> Maybe (Ptr ImVec2) -> m ()
setNextWindowPos :: forall (m :: * -> *).
MonadIO m =>
Ptr ImVec2 -> ImGuiCond -> Maybe (Ptr ImVec2) -> m ()
setNextWindowPos Ptr ImVec2
posPtr ImGuiCond
cond (Just Ptr ImVec2
pivotPtr) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowPos(*$(ImVec2* posPtr), $(ImGuiCond cond), *$(ImVec2* pivotPtr)) } |]
setNextWindowPos Ptr ImVec2
posPtr ImGuiCond
cond Maybe (Ptr ImVec2)
Nothing = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowPos(*$(ImVec2* posPtr), $(ImGuiCond cond)) } |]
setNextWindowSize :: (MonadIO m) => Ptr ImVec2 -> ImGuiCond -> m ()
setNextWindowSize :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> ImGuiCond -> m ()
setNextWindowSize Ptr ImVec2
sizePtr ImGuiCond
cond = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowSize(*$(ImVec2* sizePtr), $(ImGuiCond cond)) } |]
setNextWindowFullscreen :: (MonadIO m) => m ()
setNextWindowFullscreen :: forall (m :: * -> *). MonadIO m => m ()
setNextWindowFullscreen = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
IO ()
[C.block|
void {
SetNextWindowPos(ImVec2(0, 0));
SetNextWindowSize(GetIO().DisplaySize);
}
|]
setNextWindowContentSize :: (MonadIO m) => Ptr ImVec2 -> m ()
setNextWindowContentSize :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
setNextWindowContentSize Ptr ImVec2
sizePtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowContentSize(*$(ImVec2* sizePtr)) } |]
setNextWindowSizeConstraints :: (MonadIO m) => Ptr ImVec2 -> Ptr ImVec2 -> m ()
setNextWindowSizeConstraints :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> Ptr ImVec2 -> m ()
setNextWindowSizeConstraints Ptr ImVec2
sizeMinPtr Ptr ImVec2
sizeMaxPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowSizeConstraints(*$(ImVec2* sizeMinPtr), *$(ImVec2* sizeMaxPtr)) } |]
setNextWindowCollapsed :: (MonadIO m) => CBool -> ImGuiCond -> m ()
setNextWindowCollapsed :: forall (m :: * -> *). MonadIO m => CBool -> ImGuiCond -> m ()
setNextWindowCollapsed CBool
b ImGuiCond
cond = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowCollapsed($(bool b), $(ImGuiCond cond)) } |]
setNextWindowFocus :: (MonadIO m) => m ()
setNextWindowFocus :: forall (m :: * -> *). MonadIO m => m ()
setNextWindowFocus = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { SetNextWindowFocus() } |]
setNextWindowScroll :: (MonadIO m) => Ptr ImVec2 -> m ()
setNextWindowScroll :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
setNextWindowScroll Ptr ImVec2
posPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowScroll(*$(ImVec2* posPtr)) } |]
setNextWindowBgAlpha :: (MonadIO m) => CFloat -> m ()
setNextWindowBgAlpha :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
setNextWindowBgAlpha CFloat
alpha = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowBgAlpha($(float alpha)) } |]
getContentRegionAvail :: (MonadIO m) => m ImVec2
getContentRegionAvail :: forall (m :: * -> *). MonadIO m => m ImVec2
getContentRegionAvail = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetContentRegionAvail();
}
|]
getContentRegionMax :: (MonadIO m) => m ImVec2
getContentRegionMax :: forall (m :: * -> *). MonadIO m => m ImVec2
getContentRegionMax = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetContentRegionMax();
}
|]
getWindowContentRegionMin :: (MonadIO m) => m ImVec2
getWindowContentRegionMin :: forall (m :: * -> *). MonadIO m => m ImVec2
getWindowContentRegionMin = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetWindowContentRegionMin();
}
|]
getWindowContentRegionMax :: (MonadIO m) => m ImVec2
getWindowContentRegionMax :: forall (m :: * -> *). MonadIO m => m ImVec2
getWindowContentRegionMax = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetWindowContentRegionMax();
}
|]
beginDisabled :: (MonadIO m) => CBool -> m ()
beginDisabled :: forall (m :: * -> *). MonadIO m => CBool -> m ()
beginDisabled CBool
disabled = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { BeginDisabled($(bool disabled)) } |]
endDisabled :: (MonadIO m) => m ()
endDisabled :: forall (m :: * -> *). MonadIO m => m ()
endDisabled = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndDisabled() } |]
setItemDefaultFocus :: (MonadIO m) => m ()
setItemDefaultFocus :: forall (m :: * -> *). MonadIO m => m ()
setItemDefaultFocus = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.block| void { SetItemDefaultFocus(); } |]
setKeyboardFocusHere :: (MonadIO m) => CInt -> m ()
setKeyboardFocusHere :: forall (m :: * -> *). MonadIO m => CInt -> m ()
setKeyboardFocusHere CInt
offset = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { SetKeyboardFocusHere( $(int offset)); } |]
setNextItemAllowOverlap :: (MonadIO m) => m ()
setNextItemAllowOverlap :: forall (m :: * -> *). MonadIO m => m ()
setNextItemAllowOverlap = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.block| void { SetNextItemAllowOverlap(); } |]
newLine :: (MonadIO m) => m ()
newLine :: forall (m :: * -> *). MonadIO m => m ()
newLine = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { NewLine() } |]
spacing :: (MonadIO m) => m ()
spacing :: forall (m :: * -> *). MonadIO m => m ()
spacing = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { Spacing() } |]
dummy :: (MonadIO m) => Ptr ImVec2 -> m ()
dummy :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
dummy Ptr ImVec2
sizePtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { Dummy(*$(ImVec2* sizePtr)) } |]
indent :: (MonadIO m) => CFloat -> m ()
indent :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
indent CFloat
indent_w = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { Indent($(float indent_w)) } |]
unindent :: (MonadIO m) => CFloat -> m ()
unindent :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
unindent CFloat
indent_w = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { Unindent($(float indent_w)) } |]
setNextItemWidth :: (MonadIO m) => CFloat -> m ()
setNextItemWidth :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
setNextItemWidth CFloat
itemWidth = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextItemWidth($(float itemWidth)) } |]
pushItemWidth :: (MonadIO m) => CFloat -> m ()
pushItemWidth :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
pushItemWidth CFloat
itemWidth = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushItemWidth($(float itemWidth)) } |]
popItemWidth :: (MonadIO m) => m ()
popItemWidth :: forall (m :: * -> *). MonadIO m => m ()
popItemWidth = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { PopItemWidth() } |]
calcItemWidth :: MonadIO m => m Float
calcItemWidth :: forall (m :: * -> *). MonadIO m => m Float
calcItemWidth = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac (CFloat -> Float) -> IO CFloat -> IO Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CFloat
[C.exp| float { CalcItemWidth() } |]
pushTextWrapPos :: (MonadIO m) => CFloat -> m ()
pushTextWrapPos :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
pushTextWrapPos CFloat
wrapLocalPosX = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushTextWrapPos($(float wrapLocalPosX)) } |]
popTextWrapPos :: (MonadIO m) => m ()
popTextWrapPos :: forall (m :: * -> *). MonadIO m => m ()
popTextWrapPos = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { PopTextWrapPos() } |]
beginGroup :: (MonadIO m) => m ()
beginGroup :: forall (m :: * -> *). MonadIO m => m ()
beginGroup = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { BeginGroup() } |]
endGroup :: (MonadIO m) => m ()
endGroup :: forall (m :: * -> *). MonadIO m => m ()
endGroup = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { EndGroup() } |]
alignTextToFramePadding :: (MonadIO m) => m ()
alignTextToFramePadding :: forall (m :: * -> *). MonadIO m => m ()
alignTextToFramePadding = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { AlignTextToFramePadding() } |]
getTextLineHeight :: (MonadIO m) => m CFloat
getTextLineHeight :: forall (m :: * -> *). MonadIO m => m CFloat
getTextLineHeight = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetTextLineHeight() } |]
getTextLineHeightWithSpacing :: (MonadIO m) => m CFloat
getTextLineHeightWithSpacing :: forall (m :: * -> *). MonadIO m => m CFloat
getTextLineHeightWithSpacing = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetTextLineHeightWithSpacing() } |]
getFrameHeight :: (MonadIO m) => m CFloat
getFrameHeight :: forall (m :: * -> *). MonadIO m => m CFloat
getFrameHeight = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetFrameHeight() } |]
getFrameHeightWithSpacing :: (MonadIO m) => m CFloat
getFrameHeightWithSpacing :: forall (m :: * -> *). MonadIO m => m CFloat
getFrameHeightWithSpacing = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetFrameHeightWithSpacing() } |]
setCursorPos :: (MonadIO m) => Ptr ImVec2 -> m ()
setCursorPos :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
setCursorPos Ptr ImVec2
posPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCursorPos(*$(ImVec2* posPtr)) } |]
setCursorPosX :: (MonadIO m) => CFloat -> m ()
setCursorPosX :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
setCursorPosX CFloat
localX = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCursorPosX($(float localX)) } |]
setCursorPosY :: (MonadIO m) => CFloat -> m ()
setCursorPosY :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
setCursorPosY CFloat
localY = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCursorPosY($(float localY)) } |]
getCursorPos :: (MonadIO m) => m ImVec2
getCursorPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getCursorPos = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetCursorPos();
}
|]
getCursorPosX :: (MonadIO m) => m CFloat
getCursorPosX :: forall (m :: * -> *). MonadIO m => m CFloat
getCursorPosX = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetCursorPosX() } |]
getCursorPosY :: (MonadIO m) => m CFloat
getCursorPosY :: forall (m :: * -> *). MonadIO m => m CFloat
getCursorPosY = IO CFloat -> m CFloat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO CFloat
[C.exp| float { GetCursorPosY() } |]
getCursorScreenPos :: (MonadIO m) => m ImVec2
getCursorScreenPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getCursorScreenPos = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetCursorScreenPos();
}
|]
getCursorStartPos :: (MonadIO m) => m ImVec2
getCursorStartPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getCursorStartPos = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetCursorStartPos();
}
|]
setCursorScreenPos :: (MonadIO m) => Ptr ImVec2 -> m ()
setCursorScreenPos :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
setCursorScreenPos Ptr ImVec2
posPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCursorScreenPos(*$(ImVec2* posPtr)) } |]
pushStyleColor :: (MonadIO m) => ImGuiCol -> Ptr ImVec4 -> m ()
pushStyleColor :: forall (m :: * -> *). MonadIO m => ImGuiCol -> Ptr ImVec4 -> m ()
pushStyleColor ImGuiCol
col Ptr ImVec4
colorPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushStyleColor($(ImGuiCol col), *$(ImVec4 *colorPtr)) } |]
popStyleColor :: (MonadIO m) => CInt -> m ()
popStyleColor :: forall (m :: * -> *). MonadIO m => CInt -> m ()
popStyleColor CInt
n = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PopStyleColor($(int n)) } |]
pushStyleVar :: (MonadIO m) => ImGuiStyleVar -> Ptr ImVec2 -> m ()
pushStyleVar :: forall (m :: * -> *).
MonadIO m =>
ImGuiStyleVar -> Ptr ImVec2 -> m ()
pushStyleVar ImGuiStyleVar
style Ptr ImVec2
valPtr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushStyleVar($(ImGuiStyleVar style), *$(ImVec2* valPtr)) } |]
popStyleVar :: (MonadIO m) => CInt -> m ()
popStyleVar :: forall (m :: * -> *). MonadIO m => CInt -> m ()
popStyleVar CInt
n = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PopStyleVar($(int n)) } |]
pushTabStop :: (MonadIO m) => CBool -> m ()
pushTabStop :: forall (m :: * -> *). MonadIO m => CBool -> m ()
pushTabStop CBool
b = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushTabStop($(bool b)) } |]
popTabStop :: (MonadIO m) => m ()
popTabStop :: forall (m :: * -> *). MonadIO m => m ()
popTabStop = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { PopTabStop() } |]
pushIDInt :: (MonadIO m) => CInt -> m ()
pushIDInt :: forall (m :: * -> *). MonadIO m => CInt -> m ()
pushIDInt CInt
intId = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushID($(int intId)) } |]
pushIDPtr :: (MonadIO m) => Ptr a -> m ()
pushIDPtr :: forall (m :: * -> *) a. MonadIO m => Ptr a -> m ()
pushIDPtr Ptr a
ptr = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushID($(void * ptr_)) } |]
where
ptr_ :: Ptr b
ptr_ = Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
ptr
pushIDStr :: (MonadIO m) => CString -> m ()
pushIDStr :: forall (m :: * -> *). MonadIO m => CString -> m ()
pushIDStr CString
strId = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushID($(char * strId)) } |]
pushIDStrLen :: (MonadIO m) => CStringLen -> m ()
pushIDStrLen :: forall (m :: * -> *). MonadIO m => CStringLen -> m ()
pushIDStrLen (CString
strBegin, Int
strLen) = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PushID($(char * strBegin), $(char * strEnd)) } |]
where
strEnd :: Ptr b
strEnd = CString -> Int -> Ptr b
forall a b. Ptr a -> Int -> Ptr b
plusPtr CString
strBegin Int
strLen
popID :: (MonadIO m) => m ()
popID :: forall (m :: * -> *). MonadIO m => m ()
popID = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
IO ()
[C.exp| void { PopID() } |]
getMousePos :: (MonadIO m) => m ImVec2
getMousePos :: forall (m :: * -> *). MonadIO m => m ImVec2
getMousePos = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetMousePos();
}
|]
getMousePosOnOpeningCurrentPopup :: (MonadIO m) => m ImVec2
= IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetMousePosOnOpeningCurrentPopup();
}
|]
isMouseDragging :: MonadIO m => ImGuiMouseButton -> CFloat -> m Bool
isMouseDragging :: forall (m :: * -> *).
MonadIO m =>
ImGuiMouseButton -> CFloat -> m Bool
isMouseDragging ImGuiMouseButton
btn CFloat
lockThreshold = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { IsMouseDragging( $(ImGuiMouseButton btn), $(float lockThreshold) ) } |]
getMouseDragDelta :: (MonadIO m) => ImGuiMouseButton -> CFloat -> m ImVec2
getMouseDragDelta :: forall (m :: * -> *).
MonadIO m =>
ImGuiMouseButton -> CFloat -> m ImVec2
getMouseDragDelta ImGuiMouseButton
btn CFloat
lockThreshold = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = GetMouseDragDelta( $(ImGuiMouseButton btn), $(float lockThreshold) );
}
|]
resetMouseDragDelta :: MonadIO m => ImGuiMouseButton -> m ()
resetMouseDragDelta :: forall (m :: * -> *). MonadIO m => ImGuiMouseButton -> m ()
resetMouseDragDelta ImGuiMouseButton
btn = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { ResetMouseDragDelta( $(ImGuiMouseButton btn) ); } |]
wantCaptureMouse :: MonadIO m => m Bool
wantCaptureMouse :: forall (m :: * -> *). MonadIO m => m Bool
wantCaptureMouse = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { GetIO().WantCaptureMouse } |]
type ImGuiKeyChord = Int
shortcut :: MonadIO m => ImGuiKeyChord -> ImGuiInputFlags -> m Bool
shortcut :: forall (m :: * -> *). MonadIO m => Int -> ImGuiInputFlags -> m Bool
shortcut Int
keyChord ImGuiInputFlags
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [C.exp| bool { Shortcut( $(ImGuiKeyChord keyChord), $(ImGuiInputFlags flags) ) } |]
setNextItemShortcut :: MonadIO m => ImGuiKeyChord -> ImGuiInputFlags -> m ()
setNextItemShortcut :: forall (m :: * -> *). MonadIO m => Int -> ImGuiInputFlags -> m ()
setNextItemShortcut Int
keyChord ImGuiInputFlags
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.block| void { SetNextItemShortcut( $(ImGuiKeyChord keyChord), $(ImGuiInputFlags flags) ); } |]
wantCaptureKeyboard :: MonadIO m => m Bool
wantCaptureKeyboard :: forall (m :: * -> *). MonadIO m => m Bool
wantCaptureKeyboard = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(CBool
0 CBool -> CBool -> Bool
forall a. Eq a => a -> a -> Bool
/=) (CBool -> Bool) -> IO CBool -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CBool
[C.exp| bool { GetIO().WantCaptureKeyboard } |]
framerate :: MonadIO m => m Float
framerate :: forall (m :: * -> *). MonadIO m => m Float
framerate = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac (CFloat -> Float) -> IO CFloat -> IO Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CFloat
[C.exp| float { GetIO().Framerate } |]
getTime :: MonadIO m => m Double
getTime :: forall (m :: * -> *). MonadIO m => m Double
getTime = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac (CDouble -> Double) -> IO CDouble -> IO Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CDouble
[C.exp| double { GetTime() } |]
getFrameCount :: MonadIO m => m Int
getFrameCount :: forall (m :: * -> *). MonadIO m => m Int
getFrameCount = IO Int -> m Int
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int) -> IO CInt -> IO Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO CInt
[C.exp| int { GetFrameCount() } |]
calcTextSize :: MonadIO m => CString -> CString -> CBool -> CFloat -> m ImVec2
calcTextSize :: forall (m :: * -> *).
MonadIO m =>
CString -> CString -> CBool -> CFloat -> m ImVec2
calcTextSize CString
textPtr CString
textEndPtr CBool
hideAfterDoubleHash CFloat
wrapWidth = IO ImVec2 -> m ImVec2
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Ptr ImVec2 -> IO ()) -> IO ImVec2
forall a. Storable a => (Ptr a -> IO ()) -> IO a
C.withPtr_ \Ptr ImVec2
ptr ->
[C.block|
void {
*$(ImVec2 * ptr) = CalcTextSize(
$(char* textPtr),
$(char* textEndPtr),
$(bool hideAfterDoubleHash),
$(float wrapWidth)
);
}
|]
getBackgroundDrawList :: (MonadIO m) => m DrawList
getBackgroundDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getBackgroundDrawList = IO DrawList -> m DrawList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImDrawList -> DrawList
DrawList (Ptr ImDrawList -> DrawList) -> IO (Ptr ImDrawList) -> IO DrawList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ImDrawList)
[C.exp|
ImDrawList* {
GetBackgroundDrawList()
}
|]
getForegroundDrawList :: (MonadIO m) => m DrawList
getForegroundDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getForegroundDrawList = IO DrawList -> m DrawList
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImDrawList -> DrawList
DrawList (Ptr ImDrawList -> DrawList) -> IO (Ptr ImDrawList) -> IO DrawList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (Ptr ImDrawList)
[C.exp|
ImDrawList* {
GetForegroundDrawList()
}
|]
imCol32 :: CUChar -> CUChar -> CUChar -> CUChar -> ImU32
imCol32 :: CUChar -> CUChar -> CUChar -> CUChar -> ImGuiID
imCol32 CUChar
r CUChar
g CUChar
b CUChar
a = IO ImGuiID -> ImGuiID
forall a. IO a -> a
unsafePerformIO
[C.exp|
ImU32 {
IM_COL32(
$(unsigned char r),
$(unsigned char g),
$(unsigned char b),
$(unsigned char a)
)
}
|]