{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
module DearImGui
(
Raw.Context(..)
, Raw.createContext
, Raw.destroyContext
, Raw.getCurrentContext
, Raw.setCurrentContext
, Raw.newFrame
, Raw.endFrame
, Raw.render
, Raw.DrawData(..)
, Raw.getDrawData
, Raw.checkVersion
, Raw.showDemoWindow
, Raw.showMetricsWindow
, Raw.showAboutWindow
, Raw.showUserGuide
, getVersion
, Raw.styleColorsDark
, Raw.styleColorsLight
, Raw.styleColorsClassic
, withWindow
, withWindowOpen
, withFullscreen
, fullscreenFlags
, begin
, Raw.end
, Raw.getWindowDrawList
, Raw.getWindowPos
, Raw.getWindowSize
, Raw.getWindowWidth
, Raw.getWindowHeight
, setNextWindowPos
, setNextWindowSize
, Raw.setNextWindowFullscreen
, setNextWindowContentSize
, setNextWindowSizeConstraints
, setNextWindowCollapsed
, setNextWindowBgAlpha
, withChild
, withChildOpen
, withChildContext
, beginChild
, Raw.endChild
, withStyleColor
, pushStyleColor
, Raw.popStyleColor
, withStyleVar
, pushStyleVar
, popStyleVar
, withFont
, Raw.Font.pushFont
, Raw.Font.popFont
, Raw.Font.Font
, Raw.separator
, Raw.sameLine
, Raw.newLine
, Raw.spacing
, dummy
, withIndent
, indent
, unindent
, setNextItemWidth
, withItemWidth
, pushItemWidth
, Raw.popItemWidth
, withGroup
, Raw.beginGroup
, Raw.endGroup
, setCursorPos
, Raw.alignTextToFramePadding
, withID
, ToID(..)
, text
, textColored
, textDisabled
, textWrapped
, labelText
, bulletText
, button
, smallButton
, invisibleButton
, arrowButton
, Raw.image
, checkbox
, progressBar
, Raw.bullet
, withCombo
, withComboOpen
, beginCombo
, Raw.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
, withTable
, withTableOpen
, TableOptions(..)
, defTableOptions
, beginTable
, Raw.endTable
, tableSetupColumn
, tableSetupColumnWith
, TableColumnOptions(..)
, defTableColumnOptions
, Raw.tableHeadersRow
, Raw.tableHeader
, tableSetupScrollFreeze
, tableNextRow
, tableNextRowWith
, TableRowOptions(..)
, defTableRowOptions
, tableNextColumn
, tableSetColumnIndex
, withSortableTable
, TableSortingSpecs(..)
, tableGetColumnCount
, tableGetColumnIndex
, tableGetRowIndex
, tableGetColumnName
, tableGetColumnFlags
, tableSetColumnEnabled
, tableSetBgColor
, treeNode
, treePush
, Raw.treePop
, setNextItemOpen
, selectable
, selectableWith
, SelectableOptions(..)
, defSelectableOptions
, listBox
, plotLines
, plotHistogram
, withMenuBar
, withMenuBarOpen
, Raw.beginMenuBar
, Raw.endMenuBar
, withMainMenuBar
, withMainMenuBarOpen
, Raw.beginMainMenuBar
, Raw.endMainMenuBar
, withMenu
, withMenuOpen
, beginMenu
, Raw.endMenu
, menuItem
, withTabBar
, withTabBarOpen
, beginTabBar
, Raw.endTabBar
, withTabItem
, withTabItemOpen
, beginTabItem
, Raw.endTabItem
, tabItemButton
, setTabItemClosed
, withTooltip
, Raw.beginTooltip
, Raw.endTooltip
, withPopup
, withPopupOpen
, beginPopup
, Raw.endPopup
, withPopupModal
, withPopupModalOpen
, beginPopupModal
, itemContextPopup
, withPopupContextItemOpen
, withPopupContextItem
, beginPopupContextItem
, windowContextPopup
, withPopupContextWindowOpen
, withPopupContextWindow
, beginPopupContextWindow
, voidContextPopup
, withPopupContextVoidOpen
, withPopupContextVoid
, beginPopupContextVoid
, openPopup
, openPopupOnItemClick
, Raw.closeCurrentPopup
, isCurrentPopupOpen
, isAnyPopupOpen
, isAnyLevelPopupOpen
, Raw.isItemHovered
, Raw.wantCaptureMouse
, Raw.wantCaptureKeyboard
, withListClipper
, ClipItems(..)
, ClipRange(..)
, Raw.getBackgroundDrawList
, Raw.getForegroundDrawList
, Raw.imCol32
, module DearImGui.Enums
, module DearImGui.Structs
)
where
import Control.Monad
( when )
import Data.Bool
import Data.Foldable
( foldl' )
import Foreign
import Foreign.C
import DearImGui.Enums
import DearImGui.Internal.Text (Text)
import DearImGui.Structs
import qualified DearImGui.Internal.Text as Text
import qualified DearImGui.Raw as Raw
import qualified DearImGui.Raw.Font as Raw.Font
import qualified DearImGui.Raw.ListClipper as Raw.ListClipper
import qualified Control.Monad.Managed as Managed
import Data.StateVar
( HasGetter(get), HasSetter, ($=!) )
import Control.Monad.IO.Class
( MonadIO, liftIO )
import UnliftIO (MonadUnliftIO)
import UnliftIO.Exception (bracket, bracket_)
import qualified Data.Vector as V
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Unboxed as VU
getVersion :: MonadIO m => m Text
getVersion :: forall (m :: * -> *). MonadIO m => m Text
getVersion = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => m CString
Raw.getVersion forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CString -> IO Text
Text.peekCString
begin :: MonadIO m => Text -> m Bool
begin :: forall (m :: * -> *). MonadIO m => Text -> m Bool
begin Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
name \CString
namePtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Maybe (Ptr CBool) -> Maybe ImGuiWindowFlags -> m Bool
Raw.begin CString
namePtr forall a. Maybe a
Nothing forall a. Maybe a
Nothing
withWindow :: MonadUnliftIO m => Text -> (Bool -> m a) -> m a
withWindow :: forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withWindow Text
name = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *). MonadIO m => Text -> m Bool
begin Text
name) (forall a b. a -> b -> a
const forall (m :: * -> *). MonadIO m => m ()
Raw.end)
withWindowOpen :: MonadUnliftIO m => Text -> m () -> m ()
withWindowOpen :: forall (m :: * -> *). MonadUnliftIO m => Text -> m () -> m ()
withWindowOpen Text
name m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withWindow Text
name (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
withFullscreen :: MonadUnliftIO m => m () -> m ()
withFullscreen :: forall (m :: * -> *). MonadUnliftIO m => m () -> m ()
withFullscreen m ()
action = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket m Bool
open forall {a}. a -> m ()
close (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
where
open :: m Bool
open = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => m ()
Raw.setNextWindowFullscreen
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"FullScreen" \CString
namePtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Maybe (Ptr CBool) -> Maybe ImGuiWindowFlags -> m Bool
Raw.begin CString
namePtr (forall a. a -> Maybe a
Just forall a. Ptr a
nullPtr) (forall a. a -> Maybe a
Just ImGuiWindowFlags
fullscreenFlags)
close :: a -> m ()
close = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall (m :: * -> *). MonadIO m => m ()
Raw.end
fullscreenFlags :: ImGuiWindowFlags
fullscreenFlags :: ImGuiWindowFlags
fullscreenFlags = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall a. Bits a => a -> a -> a
(.|.) forall a. Bits a => a
zeroBits
[ ImGuiWindowFlags
ImGuiWindowFlags_NoBackground
, ImGuiWindowFlags
ImGuiWindowFlags_NoBringToFrontOnFocus
, ImGuiWindowFlags
ImGuiWindowFlags_NoDecoration
, ImGuiWindowFlags
ImGuiWindowFlags_NoFocusOnAppearing
, ImGuiWindowFlags
ImGuiWindowFlags_NoMove
, ImGuiWindowFlags
ImGuiWindowFlags_NoResize
, ImGuiWindowFlags
ImGuiWindowFlags_NoSavedSettings
, ImGuiWindowFlags
ImGuiWindowFlags_NoScrollbar
, ImGuiWindowFlags
ImGuiWindowFlags_NoScrollWithMouse
, ImGuiWindowFlags
ImGuiWindowFlags_NoTitleBar
]
beginChild :: MonadIO m => Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> m Bool
beginChild :: forall (m :: * -> *).
MonadIO m =>
Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> m Bool
beginChild Text
name ImVec2
size Bool
border ImGuiWindowFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
name \CString
namePtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr ImVec2 -> CBool -> ImGuiWindowFlags -> m Bool
Raw.beginChild CString
namePtr Ptr ImVec2
sizePtr (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
border) ImGuiWindowFlags
flags
withChild :: MonadUnliftIO m => Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> (Bool -> m a) -> m a
withChild :: forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> (Bool -> m a) -> m a
withChild Text
name ImVec2
size Bool
border ImGuiWindowFlags
flags = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> m Bool
beginChild Text
name ImVec2
size Bool
border ImGuiWindowFlags
flags) (forall a b. a -> b -> a
const forall (m :: * -> *). MonadIO m => m ()
Raw.endChild)
withChildOpen :: MonadUnliftIO m => Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> m () -> m ()
withChildOpen :: forall (m :: * -> *).
MonadUnliftIO m =>
Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> m () -> m ()
withChildOpen Text
name ImVec2
size Bool
border ImGuiWindowFlags
flags m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> ImVec2 -> Bool -> ImGuiWindowFlags -> (Bool -> m a) -> m a
withChild Text
name ImVec2
size Bool
border ImGuiWindowFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
withChildContext :: MonadUnliftIO m => Text -> (Bool -> m a) -> m a
withChildContext :: forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withChildContext Text
name Bool -> m a
action =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket
(forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
name forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.beginChildContext)
(forall a b. a -> b -> a
const forall (m :: * -> *). MonadIO m => m ()
Raw.endChild)
Bool -> m a
action
text :: MonadIO m => Text -> m ()
text :: forall (m :: * -> *). MonadIO m => Text -> m ()
text Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t \CString
textPtr ->
forall (m :: * -> *). MonadIO m => CString -> Maybe CString -> m ()
Raw.textUnformatted CString
textPtr forall a. Maybe a
Nothing
textColored :: (HasGetter ref ImVec4, MonadIO m) => ref -> Text -> m ()
textColored :: forall ref (m :: * -> *).
(HasGetter ref ImVec4, MonadIO m) =>
ref -> Text -> m ()
textColored ref
ref Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec4
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec4
currentValue \Ptr ImVec4
refPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadIO m => Ptr ImVec4 -> CString -> m ()
Raw.textColored Ptr ImVec4
refPtr
textDisabled :: MonadIO m => Text -> m ()
textDisabled :: forall (m :: * -> *). MonadIO m => Text -> m ()
textDisabled Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.textDisabled
textWrapped :: MonadIO m => Text -> m ()
textWrapped :: forall (m :: * -> *). MonadIO m => Text -> m ()
textWrapped Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.textWrapped
labelText :: MonadIO m => Text -> Text -> m ()
labelText :: forall (m :: * -> *). MonadIO m => Text -> Text -> m ()
labelText Text
label Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t \CString
textPtr ->
forall (m :: * -> *). MonadIO m => CString -> CString -> m ()
Raw.labelText CString
labelPtr CString
textPtr
bulletText :: MonadIO m => Text -> m ()
bulletText :: forall (m :: * -> *). MonadIO m => Text -> m ()
bulletText Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
t forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.bulletText
button :: MonadIO m => Text -> m Bool
button :: forall (m :: * -> *). MonadIO m => Text -> m Bool
button Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.button
smallButton :: MonadIO m => Text -> m Bool
smallButton :: forall (m :: * -> *). MonadIO m => Text -> m Bool
smallButton Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.smallButton
invisibleButton :: MonadIO m => Text -> ImVec2 -> ImGuiButtonFlags -> m Bool
invisibleButton :: forall (m :: * -> *).
MonadIO m =>
Text -> ImVec2 -> ImGuiButtonFlags -> m Bool
invisibleButton Text
label ImVec2
size ImGuiButtonFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr ImVec2 -> ImGuiButtonFlags -> m Bool
Raw.invisibleButton CString
labelPtr Ptr ImVec2
sizePtr ImGuiButtonFlags
flags
arrowButton :: MonadIO m => Text -> ImGuiDir -> m Bool
arrowButton :: forall (m :: * -> *). MonadIO m => Text -> ImGuiDir -> m Bool
arrowButton Text
strId ImGuiDir
dir = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
strId \CString
strIdPtr ->
forall (m :: * -> *). MonadIO m => CString -> ImGuiDir -> m Bool
Raw.arrowButton CString
strIdPtr ImGuiDir
dir
checkbox :: (HasSetter ref Bool, HasGetter ref Bool, MonadIO m) => Text -> ref -> m Bool
checkbox :: forall ref (m :: * -> *).
(HasSetter ref Bool, HasGetter ref Bool, MonadIO m) =>
Text -> ref -> m Bool
checkbox Text
label ref
ref = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Bool
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
currentValue) \Ptr CBool
boolPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *). MonadIO m => CString -> Ptr CBool -> m Bool
Raw.checkbox CString
labelPtr Ptr CBool
boolPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CBool
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CBool
boolPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (CBool
newValue forall a. Eq a => a -> a -> Bool
== CBool
1)
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
progressBar :: MonadIO m => Float -> Maybe Text -> m ()
progressBar :: forall (m :: * -> *). MonadIO m => Float -> Maybe Text -> m ()
progressBar Float
progress Maybe Text
overlay = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall a. Maybe Text -> (CString -> IO a) -> IO a
Text.withCStringOrNull Maybe Text
overlay \CString
overlayPtr ->
forall (m :: * -> *). MonadIO m => CFloat -> CString -> m ()
Raw.progressBar (Float -> CFloat
CFloat Float
progress) CString
overlayPtr
beginCombo :: MonadIO m => Text -> Text -> m Bool
beginCombo :: forall (m :: * -> *). MonadIO m => Text -> Text -> m Bool
beginCombo Text
label Text
previewValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
previewValue \CString
previewValuePtr ->
forall (m :: * -> *). MonadIO m => CString -> CString -> m Bool
Raw.beginCombo CString
labelPtr CString
previewValuePtr
withCombo :: MonadUnliftIO m => Text -> Text -> (Bool -> m a) -> m a
withCombo :: forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> Text -> (Bool -> m a) -> m a
withCombo Text
label Text
previewValue =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *). MonadIO m => Text -> Text -> m Bool
beginCombo Text
label Text
previewValue) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endCombo)
withComboOpen :: MonadUnliftIO m => Text -> Text -> m () -> m ()
withComboOpen :: forall (m :: * -> *).
MonadUnliftIO m =>
Text -> Text -> m () -> m ()
withComboOpen Text
label Text
previewValue m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> Text -> (Bool -> m a) -> m a
withCombo Text
label Text
previewValue (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
combo :: (MonadIO m, HasGetter ref Int, HasSetter ref Int) => Text -> ref -> [Text] -> m Bool
combo :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref Int, HasSetter ref Int) =>
Text -> ref -> [Text] -> m Bool
combo Text
label ref
selectedIndex [Text]
items = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a r. Managed a -> (a -> IO r) -> IO r
Managed.with Managed Bool
m forall (m :: * -> *) a. Monad m => a -> m a
return
where
m :: Managed Bool
m = do
Int
i <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
selectedIndex
[CString]
cStrings <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\Text
str -> forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed (forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
str)) [Text]
items
CString
labelPtr <- forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label
Ptr CInt
iPtr <- forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [CString]
cStrings \Int
len Ptr CString
itemsPtr -> do
Bool
changed <- forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
Raw.combo CString
labelPtr Ptr CInt
iPtr Ptr CString
itemsPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
i' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
iPtr
ref
selectedIndex forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
i'
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragFloat :: (MonadIO m, HasSetter ref Float, HasGetter ref Float) => Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Float, HasGetter ref Float) =>
Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat Text
desc ref
ref Float
speed Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Float
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
currentValue) \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.dragFloat CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
speed) (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CFloat
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragFloat2 :: (MonadIO m, HasSetter ref (Float, Float), HasGetter ref (Float, Float)) => Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float),
HasGetter ref (Float, Float)) =>
Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat2 Text
desc ref
ref Float
speed Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.dragFloat2 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
speed) (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
2 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragFloat3 :: (MonadIO m, HasSetter ref (Float, Float, Float), HasGetter ref (Float, Float, Float)) => Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat3 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float, Float),
HasGetter ref (Float, Float, Float)) =>
Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat3 Text
desc ref
ref Float
speed Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y, Float
z) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.dragFloat3 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
speed) (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y', CFloat
z'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragFloat4 :: (MonadIO m, HasSetter ref (Float, Float, Float, Float), HasGetter ref (Float, Float, Float, Float)) => Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat4 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float, Float, Float),
HasGetter ref (Float, Float, Float, Float)) =>
Text -> ref -> Float -> Float -> Float -> m Bool
dragFloat4 Text
desc ref
ref Float
speed Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y, Float
z, Float
u) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
u ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat -> CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.dragFloat4 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
speed) (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y', CFloat
z', CFloat
u'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
4 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
u')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragFloatRange2 :: (MonadIO m, HasSetter ref Float, HasGetter ref Float) => Text -> ref -> ref -> Float -> Float -> Float -> Text -> Text -> m Bool
dragFloatRange2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Float, HasGetter ref Float) =>
Text
-> ref -> ref -> Float -> Float -> Float -> Text -> Text -> m Bool
dragFloatRange2 Text
desc ref
refMin ref
refMax Float
speed Float
minValue Float
maxValue Text
minFmt Text
maxFmt = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Float
curMin <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
refMin
Float
curMax <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
refMax
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (Float -> CFloat
CFloat Float
curMin) \Ptr CFloat
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (Float -> CFloat
CFloat Float
curMax) \Ptr CFloat
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
minFmt \CString
minFmtPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
maxFmt \CString
maxFmtPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat
-> Ptr CFloat
-> CFloat
-> CFloat
-> CFloat
-> CString
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragFloatRange2
CString
descPtr
Ptr CFloat
minPtr Ptr CFloat
maxPtr
(Float -> CFloat
CFloat Float
speed) (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue)
CString
minFmtPtr CString
maxFmtPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CFloat Float
nextMin <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
minPtr
CFloat Float
nextMax <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
maxPtr
ref
refMin forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Float
nextMin
ref
refMax forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Float
nextMax
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragInt :: (MonadIO m, HasSetter ref Int, HasGetter ref Int) => Text -> ref -> Float -> Int -> Int -> m Bool
dragInt :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Int, HasGetter ref Int) =>
Text -> ref -> Float -> Int -> Int -> m Bool
dragInt Text
label ref
ref Float
speed Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Int
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
currentValue) \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragInt
CString
labelPtr
Ptr CInt
vPtr
(Float -> CFloat
CFloat Float
speed)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragInt2 :: (MonadIO m, HasSetter ref (Int, Int), HasGetter ref (Int, Int)) => Text -> ref -> Float -> Int -> Int -> m Bool
dragInt2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int), HasGetter ref (Int, Int)) =>
Text -> ref -> Float -> Int -> Int -> m Bool
dragInt2 Text
label ref
ref Float
speed Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y ] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragInt2
CString
labelPtr
Ptr CInt
vPtr
(Float -> CFloat
CFloat Float
speed)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
2 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragInt3 :: (MonadIO m, HasSetter ref (Int, Int, Int), HasGetter ref (Int, Int, Int)) => Text -> ref -> Float -> Int -> Int -> m Bool
dragInt3 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int, Int),
HasGetter ref (Int, Int, Int)) =>
Text -> ref -> Float -> Int -> Int -> m Bool
dragInt3 Text
label ref
ref Float
speed Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y, Int
z) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
z ] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragInt3
CString
labelPtr
Ptr CInt
vPtr
(Float -> CFloat
CFloat Float
speed)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y', CInt
z'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
z')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragInt4 :: (MonadIO m, HasSetter ref (Int, Int, Int, Int), HasGetter ref (Int, Int, Int, Int)) => Text -> ref -> Float -> Int -> Int -> m Bool
dragInt4 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int, Int, Int),
HasGetter ref (Int, Int, Int, Int)) =>
Text -> ref -> Float -> Int -> Int -> m Bool
dragInt4 Text
label ref
ref Float
speed Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y, Int
z, Int
w) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
z, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w ] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragInt4
CString
labelPtr
Ptr CInt
vPtr
(Float -> CFloat
CFloat Float
speed)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y', CInt
z', CInt
w'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
z', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
w')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragIntRange2 :: (MonadIO m, HasSetter ref Int, HasGetter ref Int) => Text -> ref -> ref -> Float -> Int -> Int -> Text -> Text -> m Bool
dragIntRange2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Int, HasGetter ref Int) =>
Text -> ref -> ref -> Float -> Int -> Int -> Text -> Text -> m Bool
dragIntRange2 Text
desc ref
refMin ref
refMax Float
speed Int
minValue Int
maxValue Text
minFmt Text
maxFmt = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Int
curMin <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
refMin
Int
curMax <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
refMax
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
curMin) \Ptr CInt
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
curMax) \Ptr CInt
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
minFmt \CString
minFmtPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
maxFmt \CString
maxFmtPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> Ptr CInt
-> CFloat
-> CInt
-> CInt
-> CString
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragIntRange2
CString
descPtr
Ptr CInt
minPtr
Ptr CInt
maxPtr
(Float -> CFloat
CFloat Float
speed)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
minFmtPtr CString
maxFmtPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
nextMin <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
minPtr
CInt
nextMax <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
maxPtr
ref
refMin forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
nextMin
ref
refMax forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
nextMax
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragScalar
:: (HasSetter ref a, HasGetter ref a, HasGetter range a, Storable a, MonadIO m)
=> Text -> ImGuiDataType -> ref -> Float -> range -> range -> Text -> ImGuiSliderFlags -> m Bool
dragScalar :: forall ref a range (m :: * -> *).
(HasSetter ref a, HasGetter ref a, HasGetter range a, Storable a,
MonadIO m) =>
Text
-> ImGuiDataType
-> ref
-> Float
-> range
-> range
-> Text
-> ImGuiSliderFlags
-> m Bool
dragScalar Text
label ImGuiDataType
dataType ref
ref Float
vSpeed range
refMin range
refMax Text
format ImGuiSliderFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
a
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
a
minValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMin
a
maxValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMax
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
currentValue \Ptr a
dataPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
minValue \Ptr a
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
maxValue \Ptr a
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
format \CString
formatPtr ->
forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CFloat
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragScalar
CString
labelPtr
ImGuiDataType
dataType
Ptr a
dataPtr
(Float -> CFloat
CFloat Float
vSpeed)
Ptr a
minPtr
Ptr a
maxPtr
CString
formatPtr
ImGuiSliderFlags
flags
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
a
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr a
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! a
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
dragScalarN
:: (HasSetter ref [a], HasGetter ref [a], HasGetter range a, Storable a, MonadIO m)
=> Text -> ImGuiDataType -> ref -> Float -> range -> range -> Text -> ImGuiSliderFlags -> m Bool
dragScalarN :: forall ref a range (m :: * -> *).
(HasSetter ref [a], HasGetter ref [a], HasGetter range a,
Storable a, MonadIO m) =>
Text
-> ImGuiDataType
-> ref
-> Float
-> range
-> range
-> Text
-> ImGuiSliderFlags
-> m Bool
dragScalarN Text
label ImGuiDataType
dataType ref
ref Float
vSpeed range
refMin range
refMax Text
format ImGuiSliderFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[a]
currentValues <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
a
minValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMin
a
maxValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMax
forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [a]
currentValues \Int
components Ptr a
dataPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
minValue \Ptr a
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
maxValue \Ptr a
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
format \CString
formatPtr ->
forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CInt
-> CFloat
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.dragScalarN
CString
labelPtr
ImGuiDataType
dataType
Ptr a
dataPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
components)
(Float -> CFloat
CFloat Float
vSpeed)
Ptr a
minPtr
Ptr a
maxPtr
CString
formatPtr
ImGuiSliderFlags
flags
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[a]
newValue <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
components Ptr a
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! [a]
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderScalar
:: (HasGetter ref a, HasSetter ref a, HasGetter range a, Storable a, MonadIO m)
=> Text -> ImGuiDataType -> ref -> range -> range -> Text -> ImGuiSliderFlags -> m Bool
sliderScalar :: forall ref a range (m :: * -> *).
(HasGetter ref a, HasSetter ref a, HasGetter range a, Storable a,
MonadIO m) =>
Text
-> ImGuiDataType
-> ref
-> range
-> range
-> Text
-> ImGuiSliderFlags
-> m Bool
sliderScalar Text
label ImGuiDataType
dataType ref
ref range
refMin range
refMax Text
format ImGuiSliderFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
a
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
a
minValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMin
a
maxValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMax
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
currentValue \Ptr a
dataPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
minValue \Ptr a
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
maxValue \Ptr a
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
format \CString
formatPtr ->
forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderScalar
CString
labelPtr
ImGuiDataType
dataType
Ptr a
dataPtr
Ptr a
minPtr
Ptr a
maxPtr
CString
formatPtr
ImGuiSliderFlags
flags
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
a
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr a
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! a
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderScalarN
:: (HasSetter value [a], HasGetter value [a], HasGetter range a, Storable a, MonadIO m)
=> Text -> ImGuiDataType -> value -> range -> range -> Text -> ImGuiSliderFlags -> m Bool
sliderScalarN :: forall value a range (m :: * -> *).
(HasSetter value [a], HasGetter value [a], HasGetter range a,
Storable a, MonadIO m) =>
Text
-> ImGuiDataType
-> value
-> range
-> range
-> Text
-> ImGuiSliderFlags
-> m Bool
sliderScalarN Text
label ImGuiDataType
dataType value
ref range
refMin range
refMax Text
format ImGuiSliderFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
[a]
currentValues <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get value
ref
a
minValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMin
a
maxValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMax
forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [a]
currentValues \Int
components Ptr a
dataPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
minValue \Ptr a
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
maxValue \Ptr a
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
format \CString
formatPtr ->
forall (m :: * -> *) a.
MonadIO m =>
CString
-> ImGuiDataType
-> Ptr a
-> CInt
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderScalarN
CString
labelPtr
ImGuiDataType
dataType
Ptr a
dataPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
components)
Ptr a
minPtr
Ptr a
maxPtr
CString
formatPtr
ImGuiSliderFlags
flags
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[a]
newValue <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
components Ptr a
dataPtr
value
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! [a]
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderFloat :: (MonadIO m, HasSetter ref Float, HasGetter ref Float) => Text -> ref -> Float -> Float -> m Bool
sliderFloat :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Float, HasGetter ref Float) =>
Text -> ref -> Float -> Float -> m Bool
sliderFloat Text
desc ref
ref Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Float
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
currentValue) \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.sliderFloat CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CFloat
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderFloat2 :: (MonadIO m, HasSetter ref (Float, Float), HasGetter ref (Float, Float)) => Text -> ref -> Float -> Float -> m Bool
sliderFloat2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float),
HasGetter ref (Float, Float)) =>
Text -> ref -> Float -> Float -> m Bool
sliderFloat2 Text
desc ref
ref Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.sliderFloat2 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
2 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderFloat3 :: (MonadIO m, HasSetter ref (Float, Float, Float), HasGetter ref (Float, Float, Float)) => Text -> ref -> Float -> Float -> m Bool
sliderFloat3 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float, Float),
HasGetter ref (Float, Float, Float)) =>
Text -> ref -> Float -> Float -> m Bool
sliderFloat3 Text
desc ref
ref Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y, Float
z) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.sliderFloat3 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y', CFloat
z'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderFloat4 :: (MonadIO m, HasSetter ref (Float, Float, Float, Float), HasGetter ref (Float, Float, Float, Float)) => Text -> ref -> Float -> Float -> m Bool
sliderFloat4 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Float, Float, Float, Float),
HasGetter ref (Float, Float, Float, Float)) =>
Text -> ref -> Float -> Float -> m Bool
sliderFloat4 Text
desc ref
ref Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Float
x, Float
y, Float
z, Float
u) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
x, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
y, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
z, forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
u ] \Ptr CFloat
floatPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CFloat -> CFloat -> CString -> m Bool
Raw.sliderFloat4 CString
descPtr Ptr CFloat
floatPtr (Float -> CFloat
CFloat Float
minValue) (Float -> CFloat
CFloat Float
maxValue) forall a. Ptr a
nullPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y', CFloat
z', CFloat
u'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
4 Ptr CFloat
floatPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z', forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
u')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderAngle :: (MonadIO m, HasSetter ref Float, HasGetter ref Float) => Text -> ref -> Float -> Float -> m Bool
sliderAngle :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Float, HasGetter ref Float) =>
Text -> ref -> Float -> Float -> m Bool
sliderAngle Text
desc ref
refRads Float
minDegs Float
maxDegs = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Float
currentRads <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
refRads
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (Float -> CFloat
CFloat Float
currentRads) \Ptr CFloat
currentRadsPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%.0f deg" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CFloat
-> CFloat
-> CFloat
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderAngle CString
descPtr Ptr CFloat
currentRadsPtr (Float -> CFloat
CFloat Float
minDegs) (Float -> CFloat
CFloat Float
maxDegs) CString
formatPtr ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CFloat Float
newRads <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
currentRadsPtr
ref
refRads forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Float
newRads
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderInt
:: (MonadIO m, HasSetter ref Int, HasGetter ref Int)
=> Text -> ref -> Int -> Int -> m Bool
sliderInt :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Int, HasGetter ref Int) =>
Text -> ref -> Int -> Int -> m Bool
sliderInt Text
label ref
ref Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Int
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
currentValue) \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderInt
CString
labelPtr
Ptr CInt
vPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderInt2
:: (MonadIO m, HasSetter ref (Int, Int), HasGetter ref (Int, Int))
=> Text -> ref -> Int -> Int -> m Bool
sliderInt2 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int), HasGetter ref (Int, Int)) =>
Text -> ref -> Int -> Int -> m Bool
sliderInt2 Text
label ref
ref Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y ] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderInt2
CString
labelPtr
Ptr CInt
vPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
2 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderInt3
:: (MonadIO m, HasSetter ref (Int, Int, Int), HasGetter ref (Int, Int, Int))
=> Text -> ref -> Int -> Int -> m Bool
sliderInt3 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int, Int),
HasGetter ref (Int, Int, Int)) =>
Text -> ref -> Int -> Int -> m Bool
sliderInt3 Text
label ref
ref Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y, Int
z) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
z ] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderInt3
CString
labelPtr
Ptr CInt
vPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y', CInt
z'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
z')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
sliderInt4
:: (MonadIO m, HasSetter ref (Int, Int, Int, Int), HasGetter ref (Int, Int, Int, Int))
=> Text -> ref -> Int -> Int -> m Bool
sliderInt4 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref (Int, Int, Int, Int),
HasGetter ref (Int, Int, Int, Int)) =>
Text -> ref -> Int -> Int -> m Bool
sliderInt4 Text
label ref
ref Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
(Int
x, Int
y, Int
z, Int
w) <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
z, forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w] \Ptr CInt
vPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.sliderInt4
CString
labelPtr
Ptr CInt
vPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CInt
x', CInt
y', CInt
z', CInt
w'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
4 Ptr CInt
vPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
x', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
y', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
z', forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
w')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
vSliderFloat
:: (HasSetter ref Float, HasGetter ref Float, MonadIO m)
=> Text -> ImVec2 -> ref -> Float -> Float -> m Bool
vSliderFloat :: forall ref (m :: * -> *).
(HasSetter ref Float, HasGetter ref Float, MonadIO m) =>
Text -> ImVec2 -> ref -> Float -> Float -> m Bool
vSliderFloat Text
label ImVec2
size ref
ref Float
minValue Float
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Float
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (Float -> CFloat
CFloat Float
currentValue) \Ptr CFloat
dataPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%.3f" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr ImVec2
-> Ptr CFloat
-> CFloat
-> CFloat
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.vSliderFloat
CString
labelPtr
Ptr ImVec2
sizePtr
Ptr CFloat
dataPtr
(Float -> CFloat
CFloat Float
minValue)
(Float -> CFloat
CFloat Float
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CFloat Float
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Float
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
vSliderInt
:: (HasSetter ref Int, HasGetter ref Int, MonadIO m)
=> Text -> ImVec2 -> ref -> Int -> Int -> m Bool
vSliderInt :: forall ref (m :: * -> *).
(HasSetter ref Int, HasGetter ref Int, MonadIO m) =>
Text -> ImVec2 -> ref -> Int -> Int -> m Bool
vSliderInt Text
label ImVec2
size ref
ref Int
minValue Int
maxValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Int
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
currentValue) \Ptr CInt
dataPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
"%d" \CString
formatPtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> Ptr ImVec2
-> Ptr CInt
-> CInt
-> CInt
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.vSliderInt
CString
labelPtr
Ptr ImVec2
sizePtr
Ptr CInt
dataPtr
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
minValue)
(forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
maxValue)
CString
formatPtr
ImGuiSliderFlags
ImGuiSliderFlags_AlwaysClamp
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
vSliderScalar
:: (HasSetter ref a, HasGetter ref a, HasGetter range a, Storable a, MonadIO m)
=> Text -> ImVec2 -> ImGuiDataType -> ref -> range -> range -> Text -> ImGuiSliderFlags -> m Bool
vSliderScalar :: forall ref a range (m :: * -> *).
(HasSetter ref a, HasGetter ref a, HasGetter range a, Storable a,
MonadIO m) =>
Text
-> ImVec2
-> ImGuiDataType
-> ref
-> range
-> range
-> Text
-> ImGuiSliderFlags
-> m Bool
vSliderScalar Text
label ImVec2
size ImGuiDataType
dataType ref
ref range
refMin range
refMax Text
format ImGuiSliderFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
a
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
a
minValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMin
a
maxValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get range
refMax
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
currentValue \Ptr a
dataPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
minValue \Ptr a
minPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with a
maxValue \Ptr a
maxPtr -> do
Bool
changed <-
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
format \CString
formatPtr ->
forall (m :: * -> *) a.
MonadIO m =>
CString
-> Ptr ImVec2
-> ImGuiDataType
-> Ptr a
-> Ptr a
-> Ptr a
-> CString
-> ImGuiSliderFlags
-> m Bool
Raw.vSliderScalar
CString
labelPtr
Ptr ImVec2
sizePtr
ImGuiDataType
dataType
Ptr a
dataPtr
Ptr a
minPtr
Ptr a
maxPtr
CString
formatPtr
ImGuiSliderFlags
flags
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
a
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr a
dataPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! a
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
inputText :: (MonadIO m, HasSetter ref Text, HasGetter ref Text) => Text -> ref -> Int -> m Bool
inputText :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
Text -> ref -> Int -> m Bool
inputText Text
label ref
ref Int
bufSize =
forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
ref -> Int -> (CStringLen -> IO Bool) -> m Bool
withInputString ref
ref Int
bufSize \CStringLen
bufPtrLen ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
Raw.inputText
CString
labelPtr
CStringLen
bufPtrLen
ImGuiInputTextFlags
ImGuiInputTextFlags_None
inputTextMultiline :: (MonadIO m, HasSetter ref Text, HasGetter ref Text) => Text -> ref -> Int -> ImVec2 -> m Bool
inputTextMultiline :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
Text -> ref -> Int -> ImVec2 -> m Bool
inputTextMultiline Text
label ref
ref Int
bufSize ImVec2
size =
forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
ref -> Int -> (CStringLen -> IO Bool) -> m Bool
withInputString ref
ref Int
bufSize \CStringLen
bufPtrLen ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> CStringLen -> Ptr ImVec2 -> ImGuiInputTextFlags -> m Bool
Raw.inputTextMultiline
CString
labelPtr
CStringLen
bufPtrLen
Ptr ImVec2
sizePtr
ImGuiInputTextFlags
ImGuiInputTextFlags_None
inputTextWithHint :: (MonadIO m, HasSetter ref Text, HasGetter ref Text) => Text -> Text -> ref -> Int -> m Bool
inputTextWithHint :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
Text -> Text -> ref -> Int -> m Bool
inputTextWithHint Text
label Text
hint ref
ref Int
bufSize =
forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
ref -> Int -> (CStringLen -> IO Bool) -> m Bool
withInputString ref
ref Int
bufSize \CStringLen
bufPtrLen ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
hint \CString
hintPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> CString -> CStringLen -> ImGuiInputTextFlags -> m Bool
Raw.inputTextWithHint
CString
labelPtr
CString
hintPtr
CStringLen
bufPtrLen
ImGuiInputTextFlags
ImGuiInputTextFlags_None
withInputString
:: (MonadIO m, HasSetter ref Text, HasGetter ref Text)
=> ref
-> Int
-> (CStringLen -> IO Bool)
-> m Bool
withInputString :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref Text, HasGetter ref Text) =>
ref -> Int -> (CStringLen -> IO Bool) -> m Bool
withInputString ref
ref Int
bufSize CStringLen -> IO Bool
action = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Text
input <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a. Text -> (CStringLen -> IO a) -> IO a
Text.withCStringLen Text
input \(CString
refPtr, Int
refSize) ->
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall {a}. Int -> IO (Ptr a)
mkBuf Int
refSize) forall a. Ptr a -> IO ()
free \CString
bufPtr -> do
forall a. Ptr a -> Ptr a -> Int -> IO ()
copyBytes CString
bufPtr CString
refPtr Int
refSize
Bool
changed <- CStringLen -> IO Bool
action (CString
bufPtr, Int
bufSize)
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
Text
newValue <- CString -> IO Text
Text.peekCString CString
bufPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Text
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
where
mkBuf :: Int -> IO (Ptr a)
mkBuf Int
refSize =
forall {a}. Int -> IO (Ptr a)
callocBytes forall a b. (a -> b) -> a -> b
$
forall a. Ord a => a -> a -> a
max Int
refSize Int
bufSize forall a. Num a => a -> a -> a
+
Int
5
colorPicker3 :: (MonadIO m, HasSetter ref ImVec3, HasGetter ref ImVec3) => Text -> ref -> m Bool
colorPicker3 :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref ImVec3, HasGetter ref ImVec3) =>
Text -> ref -> m Bool
colorPicker3 Text
desc ref
ref = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec3{Float
$sel:x:ImVec3 :: ImVec3 -> Float
x :: Float
x, Float
$sel:y:ImVec3 :: ImVec3 -> Float
y :: Float
y, Float
$sel:z:ImVec3 :: ImVec3 -> Float
z :: Float
z} <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray (forall a b. (Real a, Fractional b) => a -> b
realToFrac forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Float
x, Float
y, Float
z]) \Ptr CFloat
refPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *). MonadIO m => CString -> Ptr CFloat -> m Bool
Raw.colorPicker3 CString
descPtr Ptr CFloat
refPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
[CFloat
x', CFloat
y', CFloat
z'] <- forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
3 Ptr CFloat
refPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Float -> Float -> Float -> ImVec3
ImVec3 (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
x') (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
y') (forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
z')
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
colorButton :: (MonadIO m, HasSetter ref ImVec4, HasGetter ref ImVec4) => Text -> ref -> m Bool
colorButton :: forall (m :: * -> *) ref.
(MonadIO m, HasSetter ref ImVec4, HasGetter ref ImVec4) =>
Text -> ref -> m Bool
colorButton Text
desc ref
ref = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec4
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec4
currentValue \Ptr ImVec4
refPtr -> do
Bool
changed <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
desc \CString
descPtr ->
forall (m :: * -> *). MonadIO m => CString -> Ptr ImVec4 -> m Bool
Raw.colorButton CString
descPtr Ptr ImVec4
refPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
ImVec4
newValue <- forall a. Storable a => Ptr a -> IO a
peek Ptr ImVec4
refPtr
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! ImVec4
newValue
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
data TableOptions = TableOptions
{ TableOptions -> ImGuiTableFlags
tableFlags :: ImGuiTableFlags
, TableOptions -> ImVec2
tableOuterSize :: ImVec2
, TableOptions -> Float
tableInnerWidth :: Float
} deriving Int -> TableOptions -> ShowS
[TableOptions] -> ShowS
TableOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableOptions] -> ShowS
$cshowList :: [TableOptions] -> ShowS
show :: TableOptions -> String
$cshow :: TableOptions -> String
showsPrec :: Int -> TableOptions -> ShowS
$cshowsPrec :: Int -> TableOptions -> ShowS
Show
defTableOptions :: TableOptions
defTableOptions :: TableOptions
defTableOptions = TableOptions
{ $sel:tableFlags:TableOptions :: ImGuiTableFlags
tableFlags = ImGuiTableFlags
ImGuiTableFlags_None
, $sel:tableOuterSize:TableOptions :: ImVec2
tableOuterSize = Float -> Float -> ImVec2
ImVec2 Float
0 Float
0
, $sel:tableInnerWidth:TableOptions :: Float
tableInnerWidth = Float
0
}
beginTable :: MonadIO m => TableOptions -> Text -> Int -> m Bool
beginTable :: forall (m :: * -> *).
MonadIO m =>
TableOptions -> Text -> Int -> m Bool
beginTable TableOptions{Float
ImGuiTableFlags
ImVec2
tableInnerWidth :: Float
tableOuterSize :: ImVec2
tableFlags :: ImGuiTableFlags
$sel:tableInnerWidth:TableOptions :: TableOptions -> Float
$sel:tableOuterSize:TableOptions :: TableOptions -> ImVec2
$sel:tableFlags:TableOptions :: TableOptions -> ImGuiTableFlags
..} Text
label Int
columns = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
tableOuterSize \Ptr ImVec2
outerSizePtr ->
forall (m :: * -> *).
MonadIO m =>
CString
-> CInt -> ImGuiTableFlags -> Ptr ImVec2 -> CFloat -> m Bool
Raw.beginTable CString
labelPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
columns) ImGuiTableFlags
tableFlags Ptr ImVec2
outerSizePtr (Float -> CFloat
CFloat Float
tableInnerWidth)
withTable :: MonadUnliftIO m => TableOptions -> Text -> Int -> (Bool -> m a) -> m a
withTable :: forall (m :: * -> *) a.
MonadUnliftIO m =>
TableOptions -> Text -> Int -> (Bool -> m a) -> m a
withTable TableOptions
options Text
label Int
columns =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
TableOptions -> Text -> Int -> m Bool
beginTable TableOptions
options Text
label Int
columns) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endTable)
withTableOpen :: MonadUnliftIO m => TableOptions -> Text -> Int -> m () -> m ()
withTableOpen :: forall (m :: * -> *).
MonadUnliftIO m =>
TableOptions -> Text -> Int -> m () -> m ()
withTableOpen TableOptions
options Text
label Int
columns m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
TableOptions -> Text -> Int -> (Bool -> m a) -> m a
withTable TableOptions
options Text
label Int
columns (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
tableNextRow :: MonadIO m => m ()
tableNextRow :: forall (m :: * -> *). MonadIO m => m ()
tableNextRow = forall (m :: * -> *). MonadIO m => TableRowOptions -> m ()
tableNextRowWith TableRowOptions
defTableRowOptions
data TableRowOptions = TableRowOptions
{ TableRowOptions -> ImGuiTableRowFlags
tableRowFlags :: ImGuiTableRowFlags
, TableRowOptions -> Float
tableRowMinHeight :: Float
} deriving Int -> TableRowOptions -> ShowS
[TableRowOptions] -> ShowS
TableRowOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableRowOptions] -> ShowS
$cshowList :: [TableRowOptions] -> ShowS
show :: TableRowOptions -> String
$cshow :: TableRowOptions -> String
showsPrec :: Int -> TableRowOptions -> ShowS
$cshowsPrec :: Int -> TableRowOptions -> ShowS
Show
defTableRowOptions :: TableRowOptions
defTableRowOptions :: TableRowOptions
defTableRowOptions = TableRowOptions
{ $sel:tableRowFlags:TableRowOptions :: ImGuiTableRowFlags
tableRowFlags = ImGuiTableRowFlags
ImGuiTableRowFlags_None
, $sel:tableRowMinHeight:TableRowOptions :: Float
tableRowMinHeight = Float
0
}
tableNextRowWith :: MonadIO m => TableRowOptions -> m ()
tableNextRowWith :: forall (m :: * -> *). MonadIO m => TableRowOptions -> m ()
tableNextRowWith TableRowOptions{Float
ImGuiTableRowFlags
tableRowMinHeight :: Float
tableRowFlags :: ImGuiTableRowFlags
$sel:tableRowMinHeight:TableRowOptions :: TableRowOptions -> Float
$sel:tableRowFlags:TableRowOptions :: TableRowOptions -> ImGuiTableRowFlags
..} = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *).
MonadIO m =>
ImGuiTableRowFlags -> CFloat -> m ()
Raw.tableNextRow ImGuiTableRowFlags
tableRowFlags (Float -> CFloat
CFloat Float
tableRowMinHeight)
tableNextColumn :: MonadIO m => m () -> m ()
tableNextColumn :: forall (m :: * -> *). MonadIO m => m () -> m ()
tableNextColumn m ()
action = forall (m :: * -> *). MonadIO m => m Bool
Raw.tableNextColumn forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
tableSetColumnIndex :: MonadIO m => Int -> m Bool
tableSetColumnIndex :: forall (m :: * -> *). MonadIO m => Int -> m Bool
tableSetColumnIndex Int
column = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CInt -> m Bool
Raw.tableSetColumnIndex (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
column)
data TableColumnOptions = TableColumnOptions
{ TableColumnOptions -> ImGuiTableColumnFlags
tableColumnFlags :: ImGuiTableColumnFlags
, TableColumnOptions -> Float
tableColumnInitWidthOrWeight :: Float
, TableColumnOptions -> ImGuiID
tableColumnUserId :: ImGuiID
} deriving Int -> TableColumnOptions -> ShowS
[TableColumnOptions] -> ShowS
TableColumnOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableColumnOptions] -> ShowS
$cshowList :: [TableColumnOptions] -> ShowS
show :: TableColumnOptions -> String
$cshow :: TableColumnOptions -> String
showsPrec :: Int -> TableColumnOptions -> ShowS
$cshowsPrec :: Int -> TableColumnOptions -> ShowS
Show
defTableColumnOptions :: TableColumnOptions
defTableColumnOptions :: TableColumnOptions
defTableColumnOptions = TableColumnOptions
{ $sel:tableColumnFlags:TableColumnOptions :: ImGuiTableColumnFlags
tableColumnFlags = ImGuiTableColumnFlags
ImGuiTableColumnFlags_None
, $sel:tableColumnInitWidthOrWeight:TableColumnOptions :: Float
tableColumnInitWidthOrWeight = Float
0
, $sel:tableColumnUserId:TableColumnOptions :: ImGuiID
tableColumnUserId = ImGuiID
0
}
tableSetupColumn :: MonadIO m => Text -> m ()
tableSetupColumn :: forall (m :: * -> *). MonadIO m => Text -> m ()
tableSetupColumn = forall (m :: * -> *).
MonadIO m =>
TableColumnOptions -> Text -> m ()
tableSetupColumnWith TableColumnOptions
defTableColumnOptions
tableSetupColumnWith :: MonadIO m => TableColumnOptions -> Text -> m ()
tableSetupColumnWith :: forall (m :: * -> *).
MonadIO m =>
TableColumnOptions -> Text -> m ()
tableSetupColumnWith TableColumnOptions{Float
ImGuiID
ImGuiTableColumnFlags
tableColumnUserId :: ImGuiID
tableColumnInitWidthOrWeight :: Float
tableColumnFlags :: ImGuiTableColumnFlags
$sel:tableColumnUserId:TableColumnOptions :: TableColumnOptions -> ImGuiID
$sel:tableColumnInitWidthOrWeight:TableColumnOptions :: TableColumnOptions -> Float
$sel:tableColumnFlags:TableColumnOptions :: TableColumnOptions -> ImGuiTableColumnFlags
..} Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTableColumnFlags -> CFloat -> ImGuiID -> m ()
Raw.tableSetupColumn CString
labelPtr ImGuiTableColumnFlags
tableColumnFlags (Float -> CFloat
CFloat Float
tableColumnInitWidthOrWeight) ImGuiID
tableColumnUserId
tableSetupScrollFreeze :: MonadIO m => Int -> Int -> m ()
tableSetupScrollFreeze :: forall (m :: * -> *). MonadIO m => Int -> Int -> m ()
tableSetupScrollFreeze Int
cols Int
rows = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
Raw.tableSetupScrollFreeze (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
cols) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
rows)
data TableSortingSpecs = TableSortingSpecs
{ TableSortingSpecs -> Int
tableSortingColumn :: Int
, TableSortingSpecs -> Bool
tableSortingReverse :: Bool
, TableSortingSpecs -> ImGuiID
tableSortingUserId :: ImGuiID
} deriving (TableSortingSpecs -> TableSortingSpecs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c/= :: TableSortingSpecs -> TableSortingSpecs -> Bool
== :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c== :: TableSortingSpecs -> TableSortingSpecs -> Bool
Eq, Eq TableSortingSpecs
TableSortingSpecs -> TableSortingSpecs -> Bool
TableSortingSpecs -> TableSortingSpecs -> Ordering
TableSortingSpecs -> TableSortingSpecs -> TableSortingSpecs
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TableSortingSpecs -> TableSortingSpecs -> TableSortingSpecs
$cmin :: TableSortingSpecs -> TableSortingSpecs -> TableSortingSpecs
max :: TableSortingSpecs -> TableSortingSpecs -> TableSortingSpecs
$cmax :: TableSortingSpecs -> TableSortingSpecs -> TableSortingSpecs
>= :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c>= :: TableSortingSpecs -> TableSortingSpecs -> Bool
> :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c> :: TableSortingSpecs -> TableSortingSpecs -> Bool
<= :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c<= :: TableSortingSpecs -> TableSortingSpecs -> Bool
< :: TableSortingSpecs -> TableSortingSpecs -> Bool
$c< :: TableSortingSpecs -> TableSortingSpecs -> Bool
compare :: TableSortingSpecs -> TableSortingSpecs -> Ordering
$ccompare :: TableSortingSpecs -> TableSortingSpecs -> Ordering
Ord, Int -> TableSortingSpecs -> ShowS
[TableSortingSpecs] -> ShowS
TableSortingSpecs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TableSortingSpecs] -> ShowS
$cshowList :: [TableSortingSpecs] -> ShowS
show :: TableSortingSpecs -> String
$cshow :: TableSortingSpecs -> String
showsPrec :: Int -> TableSortingSpecs -> ShowS
$cshowsPrec :: Int -> TableSortingSpecs -> ShowS
Show)
convertTableSortingSpecs :: ImGuiTableColumnSortSpecs -> TableSortingSpecs
convertTableSortingSpecs :: ImGuiTableColumnSortSpecs -> TableSortingSpecs
convertTableSortingSpecs ImGuiTableColumnSortSpecs{ImS16
ImGuiID
ImGuiSortDirection
$sel:sortDirection:ImGuiTableColumnSortSpecs :: ImGuiTableColumnSortSpecs -> ImGuiSortDirection
$sel:sortOrder:ImGuiTableColumnSortSpecs :: ImGuiTableColumnSortSpecs -> ImS16
$sel:columnIndex:ImGuiTableColumnSortSpecs :: ImGuiTableColumnSortSpecs -> ImS16
$sel:columnUserID:ImGuiTableColumnSortSpecs :: ImGuiTableColumnSortSpecs -> ImGuiID
sortDirection :: ImGuiSortDirection
sortOrder :: ImS16
columnIndex :: ImS16
columnUserID :: ImGuiID
..} =
TableSortingSpecs
{ $sel:tableSortingColumn:TableSortingSpecs :: Int
tableSortingColumn = forall a b. (Integral a, Num b) => a -> b
fromIntegral ImS16
columnIndex
, $sel:tableSortingReverse:TableSortingSpecs :: Bool
tableSortingReverse = ImGuiSortDirection
sortDirection forall a. Eq a => a -> a -> Bool
== ImGuiSortDirection
ImGuiSortDirection_Descending
, $sel:tableSortingUserId:TableSortingSpecs :: ImGuiID
tableSortingUserId = ImGuiID
columnUserID
}
withSortableTable :: MonadIO m => (Bool -> [TableSortingSpecs] -> m ()) -> m ()
withSortableTable :: forall (m :: * -> *).
MonadIO m =>
(Bool -> [TableSortingSpecs] -> m ()) -> m ()
withSortableTable Bool -> [TableSortingSpecs] -> m ()
action = do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall (m :: * -> *).
MonadIO m =>
m (Maybe (Ptr ImGuiTableSortSpecs))
Raw.tableGetSortSpecs forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Maybe (Ptr ImGuiTableSortSpecs)
Nothing ->
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Ptr ImGuiTableSortSpecs
specsPtr -> do
ImGuiTableSortSpecs{Ptr ImGuiTableColumnSortSpecs
CInt
CBool
$sel:specsDirty:ImGuiTableSortSpecs :: ImGuiTableSortSpecs -> CBool
$sel:specsCount:ImGuiTableSortSpecs :: ImGuiTableSortSpecs -> CInt
$sel:specs:ImGuiTableSortSpecs :: ImGuiTableSortSpecs -> Ptr ImGuiTableColumnSortSpecs
specsDirty :: CBool
specsCount :: CInt
specs :: Ptr ImGuiTableColumnSortSpecs
..} <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> IO a
peek Ptr ImGuiTableSortSpecs
specsPtr
let isDirty :: Bool
isDirty = CBool
0 forall a. Eq a => a -> a -> Bool
/= CBool
specsDirty
[ImGuiTableColumnSortSpecs]
columns <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray (forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
specsCount) Ptr ImGuiTableColumnSortSpecs
specs
Bool -> [TableSortingSpecs] -> m ()
action Bool
isDirty (forall a b. (a -> b) -> [a] -> [b]
map ImGuiTableColumnSortSpecs -> TableSortingSpecs
convertTableSortingSpecs [ImGuiTableColumnSortSpecs]
columns)
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
isDirty forall a b. (a -> b) -> a -> b
$
forall (m :: * -> *). MonadIO m => Ptr ImGuiTableSortSpecs -> m ()
Raw.tableClearSortSpecsDirty Ptr ImGuiTableSortSpecs
specsPtr
tableGetColumnCount :: MonadIO m => m Int
tableGetColumnCount :: forall (m :: * -> *). MonadIO m => m Int
tableGetColumnCount =
forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => m CInt
Raw.tableGetColumnCount
tableGetColumnIndex :: MonadIO m => m Int
tableGetColumnIndex :: forall (m :: * -> *). MonadIO m => m Int
tableGetColumnIndex =
forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => m CInt
Raw.tableGetColumnIndex
tableGetRowIndex :: MonadIO m => m Int
tableGetRowIndex :: forall (m :: * -> *). MonadIO m => m Int
tableGetRowIndex =
forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => m CInt
Raw.tableGetRowIndex
tableGetColumnName :: MonadIO m => Maybe Int -> m Text
tableGetColumnName :: forall (m :: * -> *). MonadIO m => Maybe Int -> m Text
tableGetColumnName Maybe Int
c = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => Maybe CInt -> m CString
Raw.tableGetColumnName (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int
c) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CString -> IO Text
Text.peekCString
tableGetColumnFlags :: MonadIO m => Maybe Int -> m ImGuiTableColumnFlags
tableGetColumnFlags :: forall (m :: * -> *).
MonadIO m =>
Maybe Int -> m ImGuiTableColumnFlags
tableGetColumnFlags =
forall (m :: * -> *).
MonadIO m =>
Maybe CInt -> m ImGuiTableColumnFlags
Raw.tableGetColumnFlags forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (Integral a, Num b) => a -> b
fromIntegral
tableSetColumnEnabled :: MonadIO m => Int -> Bool -> m ()
tableSetColumnEnabled :: forall (m :: * -> *). MonadIO m => Int -> Bool -> m ()
tableSetColumnEnabled Int
column_n Bool
v =
forall (m :: * -> *). MonadIO m => CInt -> CBool -> m ()
Raw.tableSetColumnEnabled (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
column_n) (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
v)
tableSetBgColor :: MonadIO m => ImGuiTableBgTarget -> ImU32 -> Maybe Int -> m ()
tableSetBgColor :: forall (m :: * -> *).
MonadIO m =>
ImGuiTableBgTarget -> ImGuiID -> Maybe Int -> m ()
tableSetBgColor ImGuiTableBgTarget
target ImGuiID
color Maybe Int
column_n =
forall (m :: * -> *).
MonadIO m =>
ImGuiTableBgTarget -> ImGuiID -> Maybe CInt -> m ()
Raw.tableSetBgColor ImGuiTableBgTarget
target ImGuiID
color (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int
column_n)
treeNode :: MonadIO m => Text -> m Bool
treeNode :: forall (m :: * -> *). MonadIO m => Text -> m Bool
treeNode Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.treeNode
treePush :: MonadIO m => Text -> m ()
treePush :: forall (m :: * -> *). MonadIO m => Text -> m ()
treePush Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.treePush
setNextItemOpen :: MonadIO m => Bool -> m ()
setNextItemOpen :: forall (m :: * -> *). MonadIO m => Bool -> m ()
setNextItemOpen Bool
is_open = forall (m :: * -> *). MonadIO m => CBool -> m ()
Raw.setNextItemOpen (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
is_open)
selectable :: MonadIO m => Text -> m Bool
selectable :: forall (m :: * -> *). MonadIO m => Text -> m Bool
selectable = forall (m :: * -> *).
MonadIO m =>
SelectableOptions -> Text -> m Bool
selectableWith SelectableOptions
defSelectableOptions
data SelectableOptions = SelectableOptions
{ SelectableOptions -> Bool
selected :: Bool
, SelectableOptions -> ImGuiSelectableFlags
flags :: ImGuiSelectableFlags
, SelectableOptions -> ImVec2
size :: ImVec2
} deriving Int -> SelectableOptions -> ShowS
[SelectableOptions] -> ShowS
SelectableOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectableOptions] -> ShowS
$cshowList :: [SelectableOptions] -> ShowS
show :: SelectableOptions -> String
$cshow :: SelectableOptions -> String
showsPrec :: Int -> SelectableOptions -> ShowS
$cshowsPrec :: Int -> SelectableOptions -> ShowS
Show
defSelectableOptions :: SelectableOptions
defSelectableOptions :: SelectableOptions
defSelectableOptions = SelectableOptions
{ $sel:selected:SelectableOptions :: Bool
selected = Bool
False
, $sel:flags:SelectableOptions :: ImGuiSelectableFlags
flags = ImGuiSelectableFlags
ImGuiSelectableFlags_None
, $sel:size:SelectableOptions :: ImVec2
size = Float -> Float -> ImVec2
ImVec2 Float
0 Float
0
}
selectableWith :: MonadIO m => SelectableOptions -> Text -> m Bool
selectableWith :: forall (m :: * -> *).
MonadIO m =>
SelectableOptions -> Text -> m Bool
selectableWith (SelectableOptions Bool
selected ImGuiSelectableFlags
flags ImVec2
size) Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size \Ptr ImVec2
sizePtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> CBool -> ImGuiSelectableFlags -> Ptr ImVec2 -> m Bool
Raw.selectable CString
labelPtr (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
selected) ImGuiSelectableFlags
flags Ptr ImVec2
sizePtr
listBox :: (MonadIO m, HasGetter ref Int, HasSetter ref Int) => Text -> ref -> [Text] -> m Bool
listBox :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref Int, HasSetter ref Int) =>
Text -> ref -> [Text] -> m Bool
listBox Text
label ref
selectedIndex [Text]
items = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a r. Managed a -> (a -> IO r) -> IO r
Managed.with Managed Bool
m forall (m :: * -> *) a. Monad m => a -> m a
return
where
m :: Managed Bool
m = do
Int
i <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
selectedIndex
[CString]
cStrings <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\Text
str -> forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed (forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
str)) [Text]
items
CString
labelPtr <- forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label
Ptr CInt
iPtr <- forall (m :: * -> *) a.
MonadManaged m =>
(forall r. (a -> IO r) -> IO r) -> m a
Managed.managed forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [CString]
cStrings \Int
len Ptr CString
itemsPtr -> do
Bool
changed <- forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CInt -> Ptr CString -> CInt -> m Bool
Raw.listBox CString
labelPtr Ptr CInt
iPtr Ptr CString
itemsPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed do
CInt
i' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
iPtr
ref
selectedIndex forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
i'
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
changed
plotLines :: MonadIO m => Text -> [CFloat] -> m ()
plotLines :: forall (m :: * -> *). MonadIO m => Text -> [CFloat] -> m ()
plotLines Text
label [CFloat]
values = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [CFloat]
values \Int
len Ptr CFloat
valuesPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CInt -> m ()
Raw.plotLines CString
labelPtr Ptr CFloat
valuesPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
plotHistogram :: MonadIO m => Text -> [CFloat] -> m ()
plotHistogram :: forall (m :: * -> *). MonadIO m => Text -> [CFloat] -> m ()
plotHistogram Text
label [CFloat]
values = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen [CFloat]
values \Int
len Ptr CFloat
valuesPtr ->
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label \CString
labelPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CFloat -> CInt -> m ()
Raw.plotHistogram CString
labelPtr Ptr CFloat
valuesPtr (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
len)
withMainMenuBar :: MonadUnliftIO m => (Bool -> m a) -> m a
withMainMenuBar :: forall (m :: * -> *) a. MonadUnliftIO m => (Bool -> m a) -> m a
withMainMenuBar = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket forall (m :: * -> *). MonadIO m => m Bool
Raw.beginMainMenuBar (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endMainMenuBar)
withMainMenuBarOpen :: MonadUnliftIO m => m () -> m ()
withMainMenuBarOpen :: forall (m :: * -> *). MonadUnliftIO m => m () -> m ()
withMainMenuBarOpen m ()
action =
forall (m :: * -> *) a. MonadUnliftIO m => (Bool -> m a) -> m a
withMainMenuBar (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
withMenuBar :: MonadUnliftIO m => (Bool -> m a) -> m a
= forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket forall (m :: * -> *). MonadIO m => m Bool
Raw.beginMenuBar (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endMenuBar)
withMenuBarOpen :: MonadUnliftIO m => m () -> m ()
m ()
action =
forall (m :: * -> *) a. MonadUnliftIO m => (Bool -> m a) -> m a
withMenuBar (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
beginMenu :: MonadIO m => Text -> m Bool
Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.beginMenu
withMenu :: MonadUnliftIO m => Text -> (Bool -> m a) -> m a
Text
label = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *). MonadIO m => Text -> m Bool
beginMenu Text
label) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endMenu)
withMenuOpen :: MonadUnliftIO m => Text -> m () -> m ()
Text
label m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withMenu Text
label (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
menuItem :: MonadIO m => Text -> m Bool
Text
label = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
label forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.menuItem
beginTabBar :: MonadIO m => Text -> ImGuiTabBarFlags -> m Bool
beginTabBar :: forall (m :: * -> *).
MonadIO m =>
Text -> ImGuiTabBarFlags -> m Bool
beginTabBar Text
tabBarID ImGuiTabBarFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
tabBarID \CString
ptr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTabBarFlags -> m Bool
Raw.beginTabBar CString
ptr ImGuiTabBarFlags
flags
withTabBar :: MonadUnliftIO m => Text -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabBar :: forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabBar Text
tabBarID ImGuiTabBarFlags
flags =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
Text -> ImGuiTabBarFlags -> m Bool
beginTabBar Text
tabBarID ImGuiTabBarFlags
flags) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endTabBar)
withTabBarOpen :: MonadUnliftIO m => Text -> ImGuiTabBarFlags -> m () -> m ()
withTabBarOpen :: forall (m :: * -> *).
MonadUnliftIO m =>
Text -> ImGuiTabBarFlags -> m () -> m ()
withTabBarOpen Text
tabBarID ImGuiTabBarFlags
flags m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabBar Text
tabBarID ImGuiTabBarFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
beginTabItem :: (MonadIO m, HasGetter ref Bool, HasSetter ref Bool) => Text -> ref -> ImGuiTabBarFlags -> m Bool
beginTabItem :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref Bool, HasSetter ref Bool) =>
Text -> ref -> ImGuiTabBarFlags -> m Bool
beginTabItem Text
tabName ref
ref ImGuiTabBarFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
Bool
currentValue <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
ref
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
currentValue) \Ptr CBool
refPtr -> do
Bool
open <- forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
tabName \CString
ptrName ->
forall (m :: * -> *).
MonadIO m =>
CString -> Ptr CBool -> ImGuiTabBarFlags -> m Bool
Raw.beginTabItem CString
ptrName Ptr CBool
refPtr ImGuiTabBarFlags
flags
Bool
newValue <- (CBool
0 forall a. Eq a => a -> a -> Bool
/=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Storable a => Ptr a -> IO a
peek Ptr CBool
refPtr
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
newValue forall a. Eq a => a -> a -> Bool
/= Bool
currentValue) do
ref
ref forall t a (m :: * -> *).
(HasSetter t a, MonadIO m) =>
t -> a -> m ()
$=! Bool
newValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
open
withTabItem :: (MonadUnliftIO m, HasGetter ref Bool, HasSetter ref Bool) => Text -> ref -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabItem :: forall (m :: * -> *) ref a.
(MonadUnliftIO m, HasGetter ref Bool, HasSetter ref Bool) =>
Text -> ref -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabItem Text
tabName ref
ref ImGuiTabBarFlags
flags =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref Bool, HasSetter ref Bool) =>
Text -> ref -> ImGuiTabBarFlags -> m Bool
beginTabItem Text
tabName ref
ref ImGuiTabBarFlags
flags) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endTabItem)
withTabItemOpen :: (MonadUnliftIO m, HasGetter ref Bool, HasSetter ref Bool) => Text -> ref -> ImGuiTabBarFlags -> m () -> m ()
withTabItemOpen :: forall (m :: * -> *) ref.
(MonadUnliftIO m, HasGetter ref Bool, HasSetter ref Bool) =>
Text -> ref -> ImGuiTabBarFlags -> m () -> m ()
withTabItemOpen Text
tabName ref
ref ImGuiTabBarFlags
flags m ()
action =
forall (m :: * -> *) ref a.
(MonadUnliftIO m, HasGetter ref Bool, HasSetter ref Bool) =>
Text -> ref -> ImGuiTabBarFlags -> (Bool -> m a) -> m a
withTabItem Text
tabName ref
ref ImGuiTabBarFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
tabItemButton :: MonadIO m => Text -> ImGuiTabItemFlags -> m Bool
tabItemButton :: forall (m :: * -> *).
MonadIO m =>
Text -> ImGuiTabItemFlags -> m Bool
tabItemButton Text
tabName ImGuiTabItemFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
tabName \CString
namePtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiTabItemFlags -> m Bool
Raw.tabItemButton CString
namePtr ImGuiTabItemFlags
flags
setTabItemClosed :: MonadIO m => Text -> m ()
setTabItemClosed :: forall (m :: * -> *). MonadIO m => Text -> m ()
setTabItemClosed Text
tabName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
tabName forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.setTabItemClosed
withTooltip :: MonadUnliftIO m => m a -> m a
withTooltip :: forall (m :: * -> *) a. MonadUnliftIO m => m a -> m a
withTooltip = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ forall (m :: * -> *). MonadIO m => m ()
Raw.beginTooltip forall (m :: * -> *). MonadIO m => m ()
Raw.endTooltip
beginPopup :: MonadIO m => Text -> m Bool
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.beginPopup
withPopup :: MonadUnliftIO m => Text -> (Bool -> m a) -> m a
Text
popupId = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *). MonadIO m => Text -> m Bool
beginPopup Text
popupId) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endPopup)
withPopupOpen :: MonadUnliftIO m => Text -> m () -> m ()
Text
popupId m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withPopup Text
popupId (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
beginPopupModal :: MonadIO m => Text -> m Bool
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall (m :: * -> *). MonadIO m => CString -> m Bool
Raw.beginPopupModal
withPopupModal :: MonadUnliftIO m => Text -> (Bool -> m a) -> m a
Text
popupId = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *). MonadIO m => Text -> m Bool
beginPopupModal Text
popupId) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endPopup)
withPopupModalOpen :: MonadUnliftIO m => Text -> m () -> m ()
Text
popupId m ()
action =
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (Bool -> m a) -> m a
withPopupModal Text
popupId (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
beginPopupContextItem :: MonadIO m => Maybe Text -> ImGuiPopupFlags -> m Bool
Maybe Text
itemId ImGuiPopupFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall a. Maybe Text -> (CString -> IO a) -> IO a
Text.withCStringOrNull Maybe Text
itemId \CString
popupIdPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.beginPopupContextItem CString
popupIdPtr ImGuiPopupFlags
flags
withPopupContextItem :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
Maybe Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
Maybe Text -> ImGuiPopupFlags -> m Bool
beginPopupContextItem Maybe Text
popupId ImGuiPopupFlags
flags) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endPopup)
withPopupContextItemOpen :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> m () -> m ()
Maybe Text
popupId ImGuiPopupFlags
flags m ()
action = forall (m :: * -> *) a.
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
withPopupContextItem Maybe Text
popupId ImGuiPopupFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
itemContextPopup :: MonadUnliftIO m => m () -> m ()
= forall (m :: * -> *).
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> m () -> m ()
withPopupContextItemOpen forall a. Maybe a
Nothing ImGuiPopupFlags
ImGuiPopupFlags_MouseButtonRight
beginPopupContextWindow :: MonadIO m => Maybe Text -> ImGuiPopupFlags -> m Bool
Maybe Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall a. Maybe Text -> (CString -> IO a) -> IO a
Text.withCStringOrNull Maybe Text
popupId \CString
popupIdPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.beginPopupContextWindow CString
popupIdPtr ImGuiPopupFlags
flags
withPopupContextWindow :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
Maybe Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
Maybe Text -> ImGuiPopupFlags -> m Bool
beginPopupContextWindow Maybe Text
popupId ImGuiPopupFlags
flags) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endPopup)
withPopupContextWindowOpen :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> m () -> m ()
Maybe Text
popupId ImGuiPopupFlags
flags m ()
action = forall (m :: * -> *) a.
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
withPopupContextWindow Maybe Text
popupId ImGuiPopupFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
windowContextPopup :: MonadUnliftIO m => m () -> m ()
= forall (m :: * -> *).
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> m () -> m ()
withPopupContextWindowOpen forall a. Maybe a
Nothing ImGuiPopupFlags
ImGuiPopupFlags_MouseButtonRight
beginPopupContextVoid :: MonadIO m => Maybe Text -> ImGuiPopupFlags -> m Bool
Maybe Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall a. Maybe Text -> (CString -> IO a) -> IO a
Text.withCStringOrNull Maybe Text
popupId \CString
popupIdPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.beginPopupContextVoid CString
popupIdPtr ImGuiPopupFlags
flags
withPopupContextVoid :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
Maybe Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket (forall (m :: * -> *).
MonadIO m =>
Maybe Text -> ImGuiPopupFlags -> m Bool
beginPopupContextVoid Maybe Text
popupId ImGuiPopupFlags
flags) (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` forall (m :: * -> *). MonadIO m => m ()
Raw.endPopup)
withPopupContextVoidOpen :: MonadUnliftIO m => Maybe Text -> ImGuiPopupFlags -> m () -> m ()
Maybe Text
popupId ImGuiPopupFlags
flags m ()
action = forall (m :: * -> *) a.
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> (Bool -> m a) -> m a
withPopupContextVoid Maybe Text
popupId ImGuiPopupFlags
flags (forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
`when` m ()
action)
voidContextPopup :: MonadUnliftIO m => m () -> m ()
= forall (m :: * -> *).
MonadUnliftIO m =>
Maybe Text -> ImGuiPopupFlags -> m () -> m ()
withPopupContextWindowOpen forall a. Maybe a
Nothing ImGuiPopupFlags
ImGuiPopupFlags_MouseButtonRight
openPopup :: MonadIO m => Text -> m ()
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.openPopup
openPopupOnItemClick :: MonadIO m => Text -> ImGuiPopupFlags -> m ()
Text
popupId ImGuiPopupFlags
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall a b. (a -> b) -> a -> b
$ \CString
idPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m ()
Raw.openPopupOnItemClick CString
idPtr ImGuiPopupFlags
flags
isCurrentPopupOpen :: MonadIO m => Text -> m Bool
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall a b. (a -> b) -> a -> b
$ \CString
idPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.isPopupOpen CString
idPtr ImGuiPopupFlags
ImGuiPopupFlags_None
isAnyPopupOpen :: MonadIO m => Text -> m Bool
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall a b. (a -> b) -> a -> b
$ \CString
idPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.isPopupOpen CString
idPtr ImGuiPopupFlags
ImGuiPopupFlags_AnyPopupId
isAnyLevelPopupOpen :: MonadIO m => Text -> m Bool
Text
popupId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *) a.
MonadUnliftIO m =>
Text -> (CString -> m a) -> m a
Text.withCString Text
popupId forall a b. (a -> b) -> a -> b
$ \CString
idPtr ->
forall (m :: * -> *).
MonadIO m =>
CString -> ImGuiPopupFlags -> m Bool
Raw.isPopupOpen CString
idPtr forall a b. (a -> b) -> a -> b
$
ImGuiPopupFlags
ImGuiPopupFlags_AnyPopupId forall a. Bits a => a -> a -> a
.|. ImGuiPopupFlags
ImGuiPopupFlags_AnyPopupLevel
setNextWindowPos
:: (MonadIO m, HasGetter ref ImVec2)
=> ref
-> ImGuiCond
-> Maybe ref
-> m ()
setNextWindowPos :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> ImGuiCond -> Maybe ref -> m ()
setNextWindowPos ref
posRef ImGuiCond
cond Maybe ref
pivotMaybe = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
pos <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
posRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
pos forall a b. (a -> b) -> a -> b
$ \Ptr ImVec2
posPtr ->
case Maybe ref
pivotMaybe of
Just ref
pivotRef -> do
ImVec2
pivot <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
pivotRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
pivot forall a b. (a -> b) -> a -> b
$ \Ptr ImVec2
pivotPtr ->
forall (m :: * -> *).
MonadIO m =>
Ptr ImVec2 -> ImGuiCond -> Maybe (Ptr ImVec2) -> m ()
Raw.setNextWindowPos Ptr ImVec2
posPtr ImGuiCond
cond (forall a. a -> Maybe a
Just Ptr ImVec2
pivotPtr)
Maybe ref
Nothing ->
forall (m :: * -> *).
MonadIO m =>
Ptr ImVec2 -> ImGuiCond -> Maybe (Ptr ImVec2) -> m ()
Raw.setNextWindowPos Ptr ImVec2
posPtr ImGuiCond
cond forall a. Maybe a
Nothing
setNextWindowSize :: (MonadIO m, HasGetter ref ImVec2) => ref -> ImGuiCond -> m ()
setNextWindowSize :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> ImGuiCond -> m ()
setNextWindowSize ref
sizeRef ImGuiCond
cond = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
size' <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
sizeRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size' \Ptr ImVec2
sizePtr ->
forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> ImGuiCond -> m ()
Raw.setNextWindowSize Ptr ImVec2
sizePtr ImGuiCond
cond
setNextWindowContentSize :: (MonadIO m, HasGetter ref ImVec2) => ref -> m ()
setNextWindowContentSize :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> m ()
setNextWindowContentSize ref
sizeRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
size' <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
sizeRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size' forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
Raw.setNextWindowContentSize
setNextWindowSizeConstraints :: (MonadIO m, HasGetter ref ImVec2) => ref -> ref -> m ()
setNextWindowSizeConstraints :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> ref -> m ()
setNextWindowSizeConstraints ref
sizeMinRef ref
sizeMaxRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
sizeMin <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
sizeMinRef
ImVec2
sizeMax <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
sizeMaxRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
sizeMin \Ptr ImVec2
sizeMinPtr ->
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
sizeMax \Ptr ImVec2
sizeMaxPtr ->
forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> Ptr ImVec2 -> m ()
Raw.setNextWindowSizeConstraints Ptr ImVec2
sizeMinPtr Ptr ImVec2
sizeMaxPtr
setNextWindowCollapsed :: (MonadIO m) => Bool -> ImGuiCond -> m ()
setNextWindowCollapsed :: forall (m :: * -> *). MonadIO m => Bool -> ImGuiCond -> m ()
setNextWindowCollapsed Bool
b ImGuiCond
cond = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CBool -> ImGuiCond -> m ()
Raw.setNextWindowCollapsed (forall a. a -> a -> Bool -> a
bool CBool
0 CBool
1 Bool
b) ImGuiCond
cond
setNextWindowBgAlpha :: (MonadIO m) => Float -> m ()
setNextWindowBgAlpha :: forall (m :: * -> *). MonadIO m => Float -> m ()
setNextWindowBgAlpha Float
alpha = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CFloat -> m ()
Raw.setNextWindowBgAlpha (Float -> CFloat
CFloat Float
alpha)
dummy :: (MonadIO m, HasGetter ref ImVec2) => ref -> m ()
dummy :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> m ()
dummy ref
sizeRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
size' <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
sizeRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
size' forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
Raw.dummy
withIndent :: MonadUnliftIO m => Float -> m a -> m a
withIndent :: forall (m :: * -> *) a. MonadUnliftIO m => Float -> m a -> m a
withIndent Float
width =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *). MonadIO m => Float -> m ()
indent Float
width) (forall (m :: * -> *). MonadIO m => Float -> m ()
unindent Float
width)
indent :: (MonadIO m) => Float -> m ()
indent :: forall (m :: * -> *). MonadIO m => Float -> m ()
indent Float
indent_w = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CFloat -> m ()
Raw.indent (Float -> CFloat
CFloat Float
indent_w)
unindent :: (MonadIO m) => Float -> m ()
unindent :: forall (m :: * -> *). MonadIO m => Float -> m ()
unindent Float
f = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CFloat -> m ()
Raw.unindent (Float -> CFloat
CFloat Float
f)
setNextItemWidth :: (MonadIO m) => Float -> m ()
setNextItemWidth :: forall (m :: * -> *). MonadIO m => Float -> m ()
setNextItemWidth Float
itemWidth = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CFloat -> m ()
Raw.setNextItemWidth (Float -> CFloat
CFloat Float
itemWidth)
withItemWidth :: MonadUnliftIO m => Float -> m a -> m a
withItemWidth :: forall (m :: * -> *) a. MonadUnliftIO m => Float -> m a -> m a
withItemWidth Float
width =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *). MonadIO m => Float -> m ()
pushItemWidth Float
width) forall (m :: * -> *). MonadIO m => m ()
Raw.popItemWidth
pushItemWidth :: (MonadIO m) => Float -> m ()
pushItemWidth :: forall (m :: * -> *). MonadIO m => Float -> m ()
pushItemWidth Float
itemWidth = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CFloat -> m ()
Raw.pushItemWidth (Float -> CFloat
CFloat Float
itemWidth)
withGroup :: MonadUnliftIO m => m a -> m a
withGroup :: forall (m :: * -> *) a. MonadUnliftIO m => m a -> m a
withGroup = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ forall (m :: * -> *). MonadIO m => m ()
Raw.beginGroup forall (m :: * -> *). MonadIO m => m ()
Raw.endGroup
setCursorPos :: (MonadIO m, HasGetter ref ImVec2) => ref -> m ()
setCursorPos :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ref -> m ()
setCursorPos ref
posRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
pos <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
posRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
pos forall (m :: * -> *). MonadIO m => Ptr ImVec2 -> m ()
Raw.setCursorPos
withID :: (MonadUnliftIO m, ToID id) => id -> m a -> m a
withID :: forall (m :: * -> *) id a.
(MonadUnliftIO m, ToID id) =>
id -> m a -> m a
withID id
i = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a (m :: * -> *). (ToID a, MonadIO m) => a -> m ()
pushID id
i) forall (m :: * -> *). MonadIO m => m ()
Raw.popID
class ToID a where
pushID :: MonadIO m => a -> m ()
instance ToID CInt where
pushID :: forall (m :: * -> *). MonadIO m => CInt -> m ()
pushID = forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.pushIDInt
instance ToID Int where
pushID :: forall (m :: * -> *). MonadIO m => Int -> m ()
pushID = forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.pushIDInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
instance ToID Integer where
pushID :: forall (m :: * -> *). MonadIO m => Integer -> m ()
pushID = forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.pushIDInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger
instance {-# OVERLAPPABLE #-} ToID (Ptr a) where
pushID :: forall (m :: * -> *). MonadIO m => Ptr a -> m ()
pushID = forall (m :: * -> *) a. MonadIO m => Ptr a -> m ()
Raw.pushIDPtr
instance {-# OVERLAPPING #-} ToID (Ptr CChar) where
pushID :: forall (m :: * -> *). MonadIO m => CString -> m ()
pushID = forall (m :: * -> *). MonadIO m => CString -> m ()
Raw.pushIDStr
instance ToID (Ptr CChar, Int) where
pushID :: forall (m :: * -> *). MonadIO m => CStringLen -> m ()
pushID = forall (m :: * -> *). MonadIO m => CStringLen -> m ()
Raw.pushIDStrLen
instance ToID Text where
pushID :: forall (m :: * -> *). MonadIO m => Text -> m ()
pushID Text
t = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. Text -> (CStringLen -> IO a) -> IO a
Text.withCStringLen Text
t forall a (m :: * -> *). (ToID a, MonadIO m) => a -> m ()
pushID
withStyleColor :: (MonadUnliftIO m, HasGetter ref ImVec4) => ImGuiCol -> ref -> m a -> m a
withStyleColor :: forall (m :: * -> *) ref a.
(MonadUnliftIO m, HasGetter ref ImVec4) =>
ImGuiCol -> ref -> m a -> m a
withStyleColor ImGuiCol
color ref
ref =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec4) =>
ImGuiCol -> ref -> m ()
pushStyleColor ImGuiCol
color ref
ref) (forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.popStyleColor CInt
1)
pushStyleColor :: (MonadIO m, HasGetter ref ImVec4) => ImGuiCol -> ref -> m ()
pushStyleColor :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec4) =>
ImGuiCol -> ref -> m ()
pushStyleColor ImGuiCol
col ref
colorRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec4
color <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
colorRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec4
color \Ptr ImVec4
colorPtr ->
forall (m :: * -> *). MonadIO m => ImGuiCol -> Ptr ImVec4 -> m ()
Raw.pushStyleColor ImGuiCol
col Ptr ImVec4
colorPtr
withStyleVar :: (MonadUnliftIO m, HasGetter ref ImVec2) => ImGuiStyleVar -> ref -> m a -> m a
withStyleVar :: forall (m :: * -> *) ref a.
(MonadUnliftIO m, HasGetter ref ImVec2) =>
ImGuiStyleVar -> ref -> m a -> m a
withStyleVar ImGuiStyleVar
style ref
ref =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ImGuiStyleVar -> ref -> m ()
pushStyleVar ImGuiStyleVar
style ref
ref) (forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.popStyleVar CInt
1)
pushStyleVar :: (MonadIO m, HasGetter ref ImVec2) => ImGuiStyleVar -> ref -> m ()
pushStyleVar :: forall (m :: * -> *) ref.
(MonadIO m, HasGetter ref ImVec2) =>
ImGuiStyleVar -> ref -> m ()
pushStyleVar ImGuiStyleVar
style ref
valRef = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
ImVec2
val <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get ref
valRef
forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with ImVec2
val \Ptr ImVec2
valPtr ->
forall (m :: * -> *).
MonadIO m =>
ImGuiStyleVar -> Ptr ImVec2 -> m ()
Raw.pushStyleVar ImGuiStyleVar
style Ptr ImVec2
valPtr
popStyleVar :: (MonadIO m) => Int -> m ()
popStyleVar :: forall (m :: * -> *). MonadIO m => Int -> m ()
popStyleVar Int
n = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO do
forall (m :: * -> *). MonadIO m => CInt -> m ()
Raw.popStyleVar (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n)
withFont :: MonadUnliftIO m => Raw.Font.Font -> m a -> m a
withFont :: forall (m :: * -> *) a. MonadUnliftIO m => Font -> m a -> m a
withFont Font
font = forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> m b -> m c -> m c
bracket_ (forall (m :: * -> *). MonadIO m => Font -> m ()
Raw.Font.pushFont Font
font) forall (m :: * -> *). MonadIO m => m ()
Raw.Font.popFont
withListClipper :: (ClipItems t a, MonadUnliftIO m) => Maybe Float -> t a -> (a -> m ()) -> m ()
withListClipper :: forall (t :: * -> *) a (m :: * -> *).
(ClipItems t a, MonadUnliftIO m) =>
Maybe Float -> t a -> (a -> m ()) -> m ()
withListClipper Maybe Float
itemHeight t a
items a -> m ()
action =
forall (m :: * -> *) a b c.
MonadUnliftIO m =>
m a -> (a -> m b) -> (a -> m c) -> m c
bracket
(forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. String -> IO (Ptr a) -> IO (Ptr a)
throwIfNull String
"withListClipper: ListClipper allocation failed" forall (m :: * -> *). MonadIO m => m (Ptr ImGuiListClipper)
Raw.ListClipper.new)
forall (m :: * -> *). MonadIO m => Ptr ImGuiListClipper -> m ()
Raw.ListClipper.delete
Ptr ImGuiListClipper -> m ()
step
where
itemHeight' :: CFloat
itemHeight' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (-CFloat
1.0) Float -> CFloat
CFloat Maybe Float
itemHeight
itemCount' :: CInt
itemCount' = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Bounded a => a
maxBound forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall (t :: * -> *) a. ClipItems t a => t a -> Maybe Int
itemCount t a
items)
step :: Ptr ImGuiListClipper -> m ()
step Ptr ImGuiListClipper
clipper = do
forall (m :: * -> *).
MonadIO m =>
Ptr ImGuiListClipper -> CInt -> CFloat -> m ()
Raw.ListClipper.begin Ptr ImGuiListClipper
clipper CInt
itemCount' CFloat
itemHeight'
Ptr ImGuiListClipper -> m ()
go Ptr ImGuiListClipper
clipper
go :: Ptr ImGuiListClipper -> m ()
go Ptr ImGuiListClipper
clipper = do
Bool
doStep <- forall (m :: * -> *). MonadIO m => Ptr ImGuiListClipper -> m Bool
Raw.ListClipper.step Ptr ImGuiListClipper
clipper
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
doStep do
let
startIndex :: Int
startIndex = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Ptr ImGuiListClipper -> CInt
Raw.ListClipper.displayStart Ptr ImGuiListClipper
clipper
endIndex :: Int
endIndex = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ Ptr ImGuiListClipper -> CInt
Raw.ListClipper.displayEnd Ptr ImGuiListClipper
clipper
forall (t :: * -> *) a (m :: * -> *).
(ClipItems t a, Monad m) =>
(a -> m ()) -> t a -> m ()
stepItems a -> m ()
action forall a b. (a -> b) -> a -> b
$
forall (t :: * -> *) a. ClipItems t a => Int -> Int -> t a -> t a
clipItems Int
startIndex Int
endIndex t a
items
Ptr ImGuiListClipper -> m ()
go Ptr ImGuiListClipper
clipper
class ClipItems t a where
itemCount :: t a -> Maybe Int
clipItems :: Int -> Int -> t a -> t a
stepItems :: Monad m => (a -> m ()) -> t a -> m ()
instance ClipItems [] a where
itemCount :: [a] -> Maybe Int
itemCount = forall a b. a -> b -> a
const forall a. Maybe a
Nothing
clipItems :: Int -> Int -> [a] -> [a]
clipItems Int
displayStart Int
displayEnd =
forall a. Int -> [a] -> [a]
take (Int
displayEnd forall a. Num a => a -> a -> a
- Int
displayStart) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
drop Int
displayStart
stepItems :: forall (m :: * -> *). Monad m => (a -> m ()) -> [a] -> m ()
stepItems = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
instance ClipItems V.Vector a where
itemCount :: Vector a -> Maybe Int
itemCount = forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> Int
V.length
clipItems :: Int -> Int -> Vector a -> Vector a
clipItems Int
displayStart Int
displayEnd =
forall a. Int -> Int -> Vector a -> Vector a
V.slice Int
displayStart (Int
displayEnd forall a. Num a => a -> a -> a
- Int
displayStart)
stepItems :: forall (m :: * -> *). Monad m => (a -> m ()) -> Vector a -> m ()
stepItems = forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
V.mapM_
instance Storable a => ClipItems VS.Vector a where
itemCount :: Vector a -> Maybe Int
itemCount = forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Vector a -> Int
VS.length
clipItems :: Int -> Int -> Vector a -> Vector a
clipItems Int
displayStart Int
displayEnd =
forall a. Storable a => Int -> Int -> Vector a -> Vector a
VS.slice Int
displayStart (Int
displayEnd forall a. Num a => a -> a -> a
- Int
displayStart)
stepItems :: forall (m :: * -> *). Monad m => (a -> m ()) -> Vector a -> m ()
stepItems = forall (m :: * -> *) a b.
(Monad m, Storable a) =>
(a -> m b) -> Vector a -> m ()
VS.mapM_
instance VU.Unbox a => ClipItems VU.Vector a where
itemCount :: Vector a -> Maybe Int
itemCount = forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Unbox a => Vector a -> Int
VU.length
clipItems :: Int -> Int -> Vector a -> Vector a
clipItems Int
displayStart Int
displayEnd =
forall a. Unbox a => Int -> Int -> Vector a -> Vector a
VU.slice Int
displayStart (Int
displayEnd forall a. Num a => a -> a -> a
- Int
displayStart)
stepItems :: forall (m :: * -> *). Monad m => (a -> m ()) -> Vector a -> m ()
stepItems = forall (m :: * -> *) a b.
(Monad m, Unbox a) =>
(a -> m b) -> Vector a -> m ()
VU.mapM_
data ClipRange a = ClipRange a a
deriving (ClipRange a -> ClipRange a -> Bool
forall a. Eq a => ClipRange a -> ClipRange a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClipRange a -> ClipRange a -> Bool
$c/= :: forall a. Eq a => ClipRange a -> ClipRange a -> Bool
== :: ClipRange a -> ClipRange a -> Bool
$c== :: forall a. Eq a => ClipRange a -> ClipRange a -> Bool
Eq, ClipRange a -> ClipRange a -> Bool
ClipRange a -> ClipRange a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (ClipRange a)
forall a. Ord a => ClipRange a -> ClipRange a -> Bool
forall a. Ord a => ClipRange a -> ClipRange a -> Ordering
forall a. Ord a => ClipRange a -> ClipRange a -> ClipRange a
min :: ClipRange a -> ClipRange a -> ClipRange a
$cmin :: forall a. Ord a => ClipRange a -> ClipRange a -> ClipRange a
max :: ClipRange a -> ClipRange a -> ClipRange a
$cmax :: forall a. Ord a => ClipRange a -> ClipRange a -> ClipRange a
>= :: ClipRange a -> ClipRange a -> Bool
$c>= :: forall a. Ord a => ClipRange a -> ClipRange a -> Bool
> :: ClipRange a -> ClipRange a -> Bool
$c> :: forall a. Ord a => ClipRange a -> ClipRange a -> Bool
<= :: ClipRange a -> ClipRange a -> Bool
$c<= :: forall a. Ord a => ClipRange a -> ClipRange a -> Bool
< :: ClipRange a -> ClipRange a -> Bool
$c< :: forall a. Ord a => ClipRange a -> ClipRange a -> Bool
compare :: ClipRange a -> ClipRange a -> Ordering
$ccompare :: forall a. Ord a => ClipRange a -> ClipRange a -> Ordering
Ord, Int -> ClipRange a -> ShowS
forall a. Show a => Int -> ClipRange a -> ShowS
forall a. Show a => [ClipRange a] -> ShowS
forall a. Show a => ClipRange a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClipRange a] -> ShowS
$cshowList :: forall a. Show a => [ClipRange a] -> ShowS
show :: ClipRange a -> String
$cshow :: forall a. Show a => ClipRange a -> String
showsPrec :: Int -> ClipRange a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ClipRange a -> ShowS
Show)
instance (Ord a, Enum a, Num a) => ClipItems ClipRange a where
itemCount :: ClipRange a -> Maybe Int
itemCount (ClipRange a
_begin a
end) =
forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> Int
fromEnum a
end
clipItems :: Int -> Int -> ClipRange a -> ClipRange a
clipItems Int
clipBegin Int
clipEnd (ClipRange a
oldBegin a
oldEnd) =
forall a. a -> a -> ClipRange a
ClipRange
(forall a. Enum a => Int -> a
toEnum forall a b. (a -> b) -> a -> b
$ forall a. Ord a => a -> a -> a
max Int
clipBegin forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> Int
fromEnum a
oldBegin)
(forall a. Enum a => Int -> a
toEnum forall a b. (a -> b) -> a -> b
$ forall a. Ord a => a -> a -> a
min Int
clipEnd forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> Int
fromEnum a
oldEnd)
stepItems :: forall (m :: * -> *). Monad m => (a -> m ()) -> ClipRange a -> m ()
stepItems a -> m ()
action (ClipRange a
start a
end) =
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ a -> m ()
action [a
start .. a
end forall a. Num a => a -> a -> a
- a
1]