{-# 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
, showAboutWindow
, showUserGuide
, getVersion
, styleColorsDark
, styleColorsLight
, styleColorsClassic
, begin
, end
, getWindowDrawList
, getWindowPos
, getWindowSize
, getWindowWidth
, getWindowHeight
, setNextWindowPos
, setNextWindowSize
, setNextWindowFullscreen
, setNextWindowContentSize
, setNextWindowSizeConstraints
, setNextWindowCollapsed
, setNextWindowBgAlpha
, beginChild
, beginChildContext
, endChild
, pushStyleColor
, popStyleColor
, pushStyleVar
, popStyleVar
, separator
, sameLine
, newLine
, spacing
, dummy
, indent
, unindent
, setNextItemWidth
, pushItemWidth
, popItemWidth
, beginGroup
, endGroup
, setCursorPos
, getCursorScreenPos
, alignTextToFramePadding
, textUnformatted
, textColored
, textDisabled
, textWrapped
, labelText
, bulletText
, button
, smallButton
, invisibleButton
, arrowButton
, image
, imageButton
, checkbox
, 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
, colorPicker3
, colorButton
, beginTable
, endTable
, tableNextRow
, tableNextColumn
, tableSetColumnIndex
, tableSetupColumn
, tableSetupScrollFreeze
, tableHeadersRow
, tableHeader
, tableGetSortSpecs
, tableClearSortSpecsDirty
, tableGetColumnCount
, tableGetColumnIndex
, tableGetRowIndex
, tableGetColumnName
, tableGetColumnFlags
, tableSetColumnEnabled
, tableSetBgColor
, treeNode
, treePush
, treePop
, selectable
, listBox
, plotHistogram
, beginMenuBar
, endMenuBar
, beginMainMenuBar
, endMainMenuBar
, beginMenu
, endMenu
, menuItem
, beginTabBar
, endTabBar
, beginTabItem
, endTabItem
, tabItemButton
, setTabItemClosed
, beginTooltip
, endTooltip
, beginPopup
, beginPopupModal
, endPopup
, openPopup
, openPopupOnItemClick
, closeCurrentPopup
, beginPopupContextItem
, beginPopupContextWindow
, beginPopupContextVoid
, isPopupOpen
, pushIDInt
, pushIDPtr
, pushIDStr
, pushIDStrLen
, popID
, isItemHovered
, wantCaptureMouse
, wantCaptureKeyboard
, getBackgroundDrawList
, getForegroundDrawList
, imCol32
, 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.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 (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
<$> [C.exp| ImGuiContext* { CreateContext() } |]
destroyContext :: (MonadIO m) => Context -> m ()
destroyContext :: forall (m :: * -> *). MonadIO m => Context -> m ()
destroyContext (Context Ptr ImGuiContext
contextPtr) = IO () -> m ()
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 (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
<$> [C.exp| ImGuiContext* { GetCurrentContext() } |]
setCurrentContext :: MonadIO m => Context -> m ()
setCurrentContext :: forall (m :: * -> *). MonadIO m => Context -> m ()
setCurrentContext (Context Ptr ImGuiContext
contextPtr) = IO () -> m ()
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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { NewFrame(); } |]
endFrame :: (MonadIO m) => m ()
endFrame :: forall (m :: * -> *). MonadIO m => m ()
endFrame = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndFrame(); } |]
render :: (MonadIO m) => m ()
render :: forall (m :: * -> *). MonadIO m => m ()
render = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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
<$> [C.exp| void* { GetDrawData() } |]
checkVersion :: (MonadIO m) => m ()
checkVersion :: forall (m :: * -> *). MonadIO m => m ()
checkVersion = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { IMGUI_CHECKVERSION(); } |]
showDemoWindow :: (MonadIO m) => m ()
showDemoWindow :: forall (m :: * -> *). MonadIO m => m ()
showDemoWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { ShowDemoWindow(); } |]
showMetricsWindow :: (MonadIO m) => m ()
showMetricsWindow :: forall (m :: * -> *). MonadIO m => m ()
showMetricsWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { ShowMetricsWindow(); } |]
showAboutWindow :: (MonadIO m) => m ()
showAboutWindow :: forall (m :: * -> *). MonadIO m => m ()
showAboutWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { ShowAboutWindow(); } |]
showUserGuide :: (MonadIO m) => m ()
showUserGuide :: forall (m :: * -> *). MonadIO m => m ()
showUserGuide = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { ShowUserGuide() } |]
getVersion :: (MonadIO m) => m CString
getVersion :: forall (m :: * -> *). MonadIO m => m CString
getVersion = IO CString -> m CString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| const char* { GetVersion() } |]
styleColorsDark :: (MonadIO m) => m ()
styleColorsDark :: forall (m :: * -> *). MonadIO m => m ()
styleColorsDark = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { StyleColorsDark(); } |]
styleColorsLight :: (MonadIO m) => m ()
styleColorsLight :: forall (m :: * -> *). MonadIO m => m ()
styleColorsLight = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { StyleColorsLight(); } |]
styleColorsClassic :: (MonadIO m) => m ()
styleColorsClassic :: forall (m :: * -> *). MonadIO m => m ()
styleColorsClassic = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndChild(); } |]
separator :: (MonadIO m) => m ()
separator :: forall (m :: * -> *). MonadIO m => m ()
separator = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { Separator(); } |]
sameLine :: (MonadIO m) => m ()
sameLine :: forall (m :: * -> *). MonadIO m => m ()
sameLine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { BulletText("%s", $(char* textPtr)) } |]
button :: (MonadIO m) => CString -> m Bool
button :: forall (m :: * -> *). MonadIO m => CString -> m Bool
button CString
labelPtr = IO Bool -> m Bool
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 (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 (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 (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 (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 (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 (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)) } |]
progressBar :: (MonadIO m) => CFloat -> CString -> m ()
progressBar :: forall (m :: * -> *). MonadIO m => CFloat -> CString -> m ()
progressBar CFloat
progress CString
overlayPtr = IO () -> m ()
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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 -> m Bool
dragFloat :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
dragFloat2 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat2 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat2 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
dragFloat3 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat3 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
dragFloat4 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CFloat -> m Bool
dragFloat4 CString
descPtr Ptr CFloat
floatPtr CFloat
speed CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
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 (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 (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 (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 (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 (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 (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 (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 (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 -> m Bool
sliderFloat :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
sliderFloat2 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat2 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat2 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
sliderFloat3 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat3 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat3 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
sliderFloat4 :: (MonadIO m) => CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat4 :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> m Bool
sliderFloat4 CString
descPtr Ptr CFloat
floatPtr CFloat
minValue CFloat
maxValue = IO Bool -> m Bool
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)) } |]
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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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)
)
}
|]
colorPicker3 :: (MonadIO m) => CString -> Ptr CFloat -> m Bool
colorPicker3 :: forall (m :: * -> *). MonadIO m => CString -> Ptr CFloat -> m Bool
colorPicker3 CString
descPtr Ptr CFloat
refPtr = IO Bool -> m Bool
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) ) } |]
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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 { TableNextColumn() } |]
tableSetColumnIndex :: MonadIO m => CInt -> m Bool
tableSetColumnIndex :: forall (m :: * -> *). MonadIO m => CInt -> m Bool
tableSetColumnIndex CInt
column= IO Bool -> m Bool
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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TableHeadersRow() } |]
tableHeader :: MonadIO m => CString -> m ()
CString
labelPtr = IO () -> m ()
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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Ptr ImGuiTableSortSpecs
ptr <- [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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| int { TableGetColumnCount() } |]
tableGetColumnIndex :: MonadIO m => m CInt
tableGetColumnIndex :: forall (m :: * -> *). MonadIO m => m CInt
tableGetColumnIndex = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| int { TableGetColumnIndex() } |]
tableGetRowIndex :: MonadIO m => m CInt
tableGetRowIndex :: forall (m :: * -> *). MonadIO m => m CInt
tableGetRowIndex = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { TreePop() } |]
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 (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 (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)) }|]
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 (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 (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 { BeginMenuBar() } |]
endMenuBar :: (MonadIO m) => m ()
= IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndMenuBar(); } |]
beginMainMenuBar :: (MonadIO m) => m Bool
beginMainMenuBar :: forall (m :: * -> *). MonadIO m => m Bool
beginMainMenuBar = IO Bool -> m Bool
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 { BeginMainMenuBar() } |]
endMainMenuBar :: (MonadIO m) => m ()
endMainMenuBar :: forall (m :: * -> *). MonadIO m => m ()
endMainMenuBar = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndMainMenuBar(); } |]
beginMenu :: (MonadIO m) => CString -> m Bool
CString
labelPtr = IO Bool -> m Bool
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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndMenu(); } |]
menuItem :: (MonadIO m) => CString -> m Bool
CString
labelPtr = IO Bool -> m Bool
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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndTabBar(); } |]
beginTabItem :: (MonadIO m) => CString -> Ptr CBool -> ImGuiTabBarFlags -> m Bool
beginTabItem :: forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CBool -> ImGuiTabBarFlags -> m Bool
beginTabItem CString
namePtr Ptr CBool
refPtr ImGuiTabBarFlags
flags = IO Bool -> m Bool
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), $(ImGuiTabBarFlags flags) ) } |]
endTabItem :: (MonadIO m) => m ()
endTabItem :: forall (m :: * -> *). MonadIO m => m ()
endTabItem = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetTabItemClosed($(char* namePtr)); } |]
beginTooltip :: (MonadIO m) => m ()
beginTooltip :: forall (m :: * -> *). MonadIO m => m ()
beginTooltip = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { BeginTooltip() } |]
endTooltip :: (MonadIO m) => m ()
endTooltip :: forall (m :: * -> *). MonadIO m => m ()
endTooltip = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndTooltip() } |]
beginPopup :: (MonadIO m) => CString -> m Bool
CString
popupIdPtr = IO Bool -> m Bool
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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndPopup() } |]
openPopup :: (MonadIO m) => CString -> m ()
CString
popupIdPtr = IO () -> m ()
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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { CloseCurrentPopup() } |]
beginPopupContextItem :: (MonadIO m) => CString -> ImGuiPopupFlags-> m Bool
CString
popupIdPtr ImGuiPopupFlags
flags = IO Bool -> m Bool
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 (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 (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 (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 (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 { IsItemHovered() } |]
getWindowDrawList :: (MonadIO m) => m DrawList
getWindowDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getWindowDrawList = IO DrawList -> m DrawList
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
<$> [C.exp|
ImDrawList* {
GetWindowDrawList()
}
|]
getWindowPos :: (MonadIO m) => m ImVec2
getWindowPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getWindowPos = IO ImVec2 -> m ImVec2
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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| float { GetWindowWidth() } |]
getWindowHeight :: (MonadIO m) => m CFloat
getWindowHeight :: forall (m :: * -> *). MonadIO m => m CFloat
getWindowHeight = IO CFloat -> m CFloat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
[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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowCollapsed($(bool b), $(ImGuiCond cond)) } |]
setNextWindowBgAlpha :: (MonadIO m) => CFloat -> m ()
setNextWindowBgAlpha :: forall (m :: * -> *). MonadIO m => CFloat -> m ()
setNextWindowBgAlpha CFloat
alpha = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetNextWindowBgAlpha($(float alpha)) } |]
newLine :: (MonadIO m) => m ()
newLine :: forall (m :: * -> *). MonadIO m => m ()
newLine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { NewLine() } |]
spacing :: (MonadIO m) => m ()
spacing :: forall (m :: * -> *). MonadIO m => m ()
spacing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[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 (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 (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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PopItemWidth() } |]
beginGroup :: (MonadIO m) => m ()
beginGroup :: forall (m :: * -> *). MonadIO m => m ()
beginGroup = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { BeginGroup() } |]
endGroup :: (MonadIO m) => m ()
endGroup :: forall (m :: * -> *). MonadIO m => m ()
endGroup = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { EndGroup() } |]
alignTextToFramePadding :: (MonadIO m) => m ()
alignTextToFramePadding :: forall (m :: * -> *). MonadIO m => m ()
alignTextToFramePadding = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { AlignTextToFramePadding() } |]
setCursorPos :: (MonadIO m) => Ptr ImVec2 -> m ()
setCursorPos :: forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
setCursorPos Ptr ImVec2
posPtr = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { SetCursorPos(*$(ImVec2* posPtr)) } |]
getCursorScreenPos :: (MonadIO m) => m ImVec2
getCursorScreenPos :: forall (m :: * -> *). MonadIO m => m ImVec2
getCursorScreenPos = IO ImVec2 -> m ImVec2
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();
}
|]
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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PopStyleVar($(int n)) } |]
pushIDInt :: (MonadIO m) => CInt -> m ()
pushIDInt :: forall (m :: * -> *). MonadIO m => CInt -> m ()
pushIDInt CInt
intId = IO () -> m ()
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 (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 (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 (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 (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[C.exp| void { PopID() } |]
wantCaptureMouse :: MonadIO m => m Bool
wantCaptureMouse :: forall (m :: * -> *). MonadIO m => m Bool
wantCaptureMouse = IO Bool -> m Bool
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 { GetIO().WantCaptureMouse } |]
wantCaptureKeyboard :: MonadIO m => m Bool
wantCaptureKeyboard :: forall (m :: * -> *). MonadIO m => m Bool
wantCaptureKeyboard = IO Bool -> m Bool
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 { GetIO().WantCaptureKeyboard } |]
getBackgroundDrawList :: (MonadIO m) => m DrawList
getBackgroundDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getBackgroundDrawList = IO DrawList -> m DrawList
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
<$> [C.exp|
ImDrawList* {
GetBackgroundDrawList()
}
|]
getForegroundDrawList :: (MonadIO m) => m DrawList
getForegroundDrawList :: forall (m :: * -> *). MonadIO m => m DrawList
getForegroundDrawList = IO DrawList -> m DrawList
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
<$> [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)
)
}
|]