-- GENERATED by C->Haskell Compiler, version 0.16.3 Crystal Seed, 24 Jan 2009 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE TypeSynonymInstances #-}

-- This source file is part of HGamer3D
-- (A project to enable 3D game development in Haskell)
-- For the latest info, see http://www.althainz.de/HGamer3D.html
-- 

-- (c) 2011, 2012 Peter Althainz
-- 
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
-- 
--     http://www.apache.org/licenses/LICENSE-2.0
-- 
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-- 


-- ClassSystem.chs

-- 

module HGamer3D.Bindings.CEGUI.ClassSystem where

import Foreign
import Foreign.Ptr
import Foreign.C

import HGamer3D.Data.HG3DClass
import HGamer3D.Data.Vector
import HGamer3D.Data.Colour
import HGamer3D.Data.Angle

import HGamer3D.Bindings.CEGUI.Utils
{-# LINE 40 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}
import HGamer3D.Bindings.CEGUI.ClassPtr
{-# LINE 41 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}
import HGamer3D.Bindings.CEGUI.StructHG3DClass
{-# LINE 42 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}
import HGamer3D.Bindings.CEGUI.EnumMouseButton
{-# LINE 43 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Create the System
create :: HG3DClass  -- ^ renderer - Reference to a valid Renderer object that will be used to render GUI imagery.
  ->  HG3DClass  -- ^ resourceProvider - Pointer to a ResourceProvider object, or NULL to use whichever default the Renderer provides.
  ->  HG3DClass  -- ^ xmlParser - Pointer to a valid XMLParser object to be used when parsing XML files, or NULL to use a default parser.
  ->  HG3DClass  -- ^ imageCodec - Pointer to a valid ImageCodec object to be used when loading image files, or NULL to use a default image codec.
  ->  HG3DClass  -- ^ scriptModule - Pointer to a ScriptModule object. may be NULL for none.
  ->  String  -- ^ configFile - String object containing the name of a configuration file to use.
  ->  String  -- ^ logFile - String object containing the name to use for the log file. 
  ->  IO (HG3DClass)
 -- ^ 
create a1 a2 a3 a4 a5 a6 a7 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  withHG3DClass a3 $ \a3' -> 
  withHG3DClass a4 $ \a4' -> 
  withHG3DClass a5 $ \a5' -> 
  withCString a6 $ \a6' -> 
  withCString a7 $ \a7' -> 
  alloca $ \a8' -> 
  create'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
  peek  a8'>>= \a8'' -> 
  return (a8'')
{-# LINE 55 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Destroy the System
destroy :: IO ()
 -- ^ 
destroy =
  destroy'_ >>= \res ->
  return ()
{-# LINE 59 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return singleton System
getSingleton :: IO (HG3DClass)
 -- ^ return value - Singleton     
getSingleton =
  alloca $ \a1' -> 
  getSingleton'_ a1' >>= \res ->
  peek  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 63 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return pointer to singleton System
getSingletonPtr :: IO (HG3DClass)
 -- ^ return value - Pointer to singleton     
getSingletonPtr =
  alloca $ \a1' -> 
  getSingletonPtr'_ a1' >>= \res ->
  peek  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 67 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Static member to set the name of the default XML parser module that should be used.  - Details: If you want to modify the default parser from the one compiled in, you
--need to call this static member prior to instantiating the main
--CEGUI::System object.
--
--Note that calling this member to change the name of the default module
--after CEGUI::System, and therefore the default xml parser, has been
--created will have no real effect - the default parser name will be
--updated, though no actual changes to the xml parser module will occur.
--
--The built-in options for this are:
-- - XercesParser
-- - ExpatParser
-- - LibxmlParser
-- - TinyXMLParser
--
--Whether these are actually available, depends upon how you built the
--system.  If you have some custom parser, you can provide the name of
--that here to have it used as the default, though note that the
--final filename of the parser module should be of the form:
--
--[prefix]CEGUI[parserName][suffix]
--
--where:
--- [prefix] is some optional prefix; like 'lib' on linux.
--- CEGUI is a required prefix.
--- [parserName] is the name of the parser, as supplied to this function.
--- [suffix] is the filename suffix, like .dll or .so
--
--Final module filenames are, thus, of the form:
--- CEGUIXercesParser.dll
--- libCEGUIXercesParser.so
--
setDefaultXMLParserName :: String  -- ^ parserName
  ->  IO ()
 -- ^ 
setDefaultXMLParserName a1 =
  withCString a1 $ \a1' -> 
  setDefaultXMLParserName'_ a1' >>= \res ->
  return ()
{-# LINE 71 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the name of the currently set default xml parser module. 
getDefaultXMLParserName :: IO (String)
 -- ^ return value - String holding the currently set default xml parser name. Note that if this name has been changed after instantiating the system, the name returned may not actually correspond to the module in use.     
getDefaultXMLParserName =
  alloc64k $ \a1' -> 
  getDefaultXMLParserName'_ a1' >>= \res ->
  peekCString  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 75 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the name of the default image codec to be used. 
setDefaultImageCodecName :: String  -- ^ codecName
  ->  IO ()
 -- ^ 
setDefaultImageCodecName a1 =
  withCString a1 $ \a1' -> 
  setDefaultImageCodecName'_ a1' >>= \res ->
  return ()
{-# LINE 79 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Get the name of the default image codec. 
getDefaultImageCodecName :: IO (String)
 -- ^ 
getDefaultImageCodecName =
  alloc64k $ \a1' -> 
  getDefaultImageCodecName'_ a1' >>= \res ->
  peekCString  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 83 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the Renderer
getRenderer :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the     
getRenderer a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRenderer'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 88 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the default font to be used by the system. 
setDefaultFont :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object containing the name of the font to be used as the system default.
  ->  IO ()
 -- ^ return value - Nothing.     
setDefaultFont a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setDefaultFont'_ a1' a2' >>= \res ->
  return ()
{-# LINE 93 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the default font to be used by the system. 
setDefaultFont2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ font - Pointer to the font to be used as the system default.
  ->  IO ()
 -- ^ return value - Nothing.     
setDefaultFont2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setDefaultFont2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 98 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the default Font
getDefaultFont :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to a     
getDefaultFont a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDefaultFont'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 103 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Causes a full re-draw next time renderGUI()
signalRedraw :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
signalRedraw a1 =
  withHG3DClass a1 $ \a1' -> 
  signalRedraw'_ a1' >>= \res ->
  return ()
{-# LINE 107 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a boolean value to indicate whether a full re-draw is requested next time renderGUI()
isRedrawRequested :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ return value - true if a re-draw has been requested     
isRedrawRequested a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isRedrawRequested'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 112 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Render the GUI.  - Details: Depending upon the internal state, this may either re-use rendering from last time, or trigger a full re-draw from all elements.
--
renderGUI :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
renderGUI a1 =
  withHG3DClass a1 $ \a1' -> 
  renderGUI'_ a1' >>= \res ->
  return ()
{-# LINE 116 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the active GUI sheet (root) window. 
setGUISheet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ sheet - Pointer to a Window object that will become the new GUI 'root'
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the window that was previously set as the GUI root.     
setGUISheet a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  setGUISheet'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 122 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the active GUI sheet (root) window. 
getGUISheet :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the window object that has been set as the GUI root element.     
getGUISheet a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getGUISheet'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 127 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the current timeout for generation of single-click events.  - Details: A single-click is defined here as a button being pressed and then released.
--
getSingleClickTimeout :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Double)
 -- ^ 
getSingleClickTimeout a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSingleClickTimeout'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 132 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the current timeout for generation of multi-click events.  - Details: A multi-click event is a double-click, or a triple-click.  The value returned
--here is the maximum allowable time between mouse button down events for which
--a multi-click event will be generated.
--
getMultiClickTimeout :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Double)
 -- ^ 
getMultiClickTimeout a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getMultiClickTimeout'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 137 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the timeout used for generation of single-click events.  - Details: A single-click is defined here as a button being pressed and then
--released.
--
setSingleClickTimeout :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Double  -- ^ timeout
  ->  IO ()
 -- ^ 
setSingleClickTimeout a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setSingleClickTimeout'_ a1' a2' >>= \res ->
  return ()
{-# LINE 142 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the timeout to be used for the generation of multi-click events.  - Details: A multi-click event is a double-click, or a triple-click.  The value
--returned here is the maximum allowable time between mouse button down
--events for which a multi-click event will be generated.
--
setMultiClickTimeout :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Double  -- ^ timeout
  ->  IO ()
 -- ^ 
setMultiClickTimeout a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setMultiClickTimeout'_ a1' a2' >>= \res ->
  return ()
{-# LINE 147 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return whether automatic mouse button click and multi-click (i.e. double-click and treble-click) event generation is enabled. 
isMouseClickEventGenerationEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isMouseClickEventGenerationEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isMouseClickEventGenerationEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 152 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set whether automatic mouse button click and multi-click (i.e. double-click and treble-click) event generation will occur. 
setMouseClickEventGenerationEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enable - 
--
--
  ->  IO ()
 -- ^ 
setMouseClickEventGenerationEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setMouseClickEventGenerationEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 157 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the image to be used as the default mouse cursor. 
setDefaultMouseCursor3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ imageset - String object that contains the name of the Imageset that contains the image to be used.
  ->  String  -- ^ image_name - String object that contains the name of the Image on imageset that is to be used.
  ->  IO ()
 -- ^ return value - Nothing.    
setDefaultMouseCursor3 a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withCString a3 $ \a3' -> 
  setDefaultMouseCursor3'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 163 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the Window
getWindowContainingMouse :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the     
getWindowContainingMouse a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getWindowContainingMouse'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 168 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the ScriptModule
getScriptingModule :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to a     
getScriptingModule a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getScriptingModule'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 173 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the ScriptModule
setScriptingModule :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ scriptModule - Pointer to a ScriptModule based object, or 0 for none (be careful!)
  ->  IO ()
 -- ^ return value - Nothing     
setScriptingModule a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setScriptingModule'_ a1' a2' >>= \res ->
  return ()
{-# LINE 178 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the ResourceProvider
getResourceProvider :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to a     
getResourceProvider a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getResourceProvider'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 183 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Execute a script file if possible. 
executeScriptFile :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ filename - String object holding the filename of the script file that is to be executed
  ->  String  -- ^ resourceGroup - Resource group identifier to be passed to the ResourceProvider when loading the script file. 
  ->  IO ()
 -- ^ 
executeScriptFile a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withCString a3 $ \a3' -> 
  executeScriptFile'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 189 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Execute a scripted global function if possible. The function should not take any parameters and should return an integer. 
executeScriptGlobal :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ function_name - String object holding the name of the function, in the global script environment, that is to be executed.
  ->  IO (Int)
 -- ^ return value - The integer value returned from the script function.     
executeScriptGlobal a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  executeScriptGlobal'_ a1' a2' a3' >>= \res ->
  peekIntConv  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 195 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | If possible, execute script code contained in the given CEGUI::String object. 
executeScriptString :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ str - String object holding the valid script code that should be executed.
  ->  IO ()
 -- ^ return value - Nothing.     
executeScriptString a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  executeScriptString'_ a1' a2' >>= \res ->
  return ()
{-# LINE 200 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | return the current mouse movement scaling factor. 
getMouseMoveScaling :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - float value that is equal to the currently set mouse movement scaling factor. Defaults to 1.0f.     
getMouseMoveScaling a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getMouseMoveScaling'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 205 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the current mouse movement scaling factor. 
setMouseMoveScaling :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ scaling - float value specifying the scaling to be applied to mouse movement inputs.
  ->  IO ()
 -- ^ return value - nothing.     
setMouseMoveScaling a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setMouseMoveScaling'_ a1' a2' >>= \res ->
  return ()
{-# LINE 210 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Internal method used to inform the SystemSystem - Details: This method is not intended for client code usage. If you use this method anything can, and probably will, go wrong! 
notifyWindowDestroyed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ window
  ->  IO ()
 -- ^ 
notifyWindowDestroyed a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  notifyWindowDestroyed'_ a1' a2' >>= \res ->
  return ()
{-# LINE 215 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the current system keys value. 
getSystemKeys :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ return value - uint value representing a combination of the SystemKey bits.     
getSystemKeys a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getSystemKeys'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 220 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set a new XML parser module to be used.  - Details: The current XMLParser will be cleaned up and, if owned by the system,
--also deleted, as will any dynamically loaded module associated with the
--XMLParser object.  The newly created XMLParser object, and the
--associated module will be owned by the system.
--
setXMLParser :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ parserName
  ->  IO ()
 -- ^ 
setXMLParser a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setXMLParser'_ a1' a2' >>= \res ->
  return ()
{-# LINE 225 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Sets the XMLParser - Details: The current XMLParser will be cleaned up and, if owned by the system,
--also deleted, as will any dynamically loaded module associated with the
--XMLParser object.
--
--If the argument passed in the \a parser parameter is 0, the system will
--cleanup any existing parser as described above, and revert to using
--the parser provided by the default module (see getDefaultXMLParserName
--and setDefaultXMLParserName).
--
setXMLParser2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ parser
  ->  IO ()
 -- ^ 
setXMLParser2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setXMLParser2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 230 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return the XMLParser
getXMLParser :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getXMLParser a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getXMLParser'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 235 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the system default TooltipTooltip
setDefaultTooltip :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ tooltip - Pointer to a valid Tooltip based object which should be used as the default tooltip for the system, or NULL to indicate that no system default tooltip is required. Note that when passing a pointer to a Tooltip object, ownership of the Tooltip does not pass to System.
  ->  IO ()
 -- ^ return value - Nothing.     
setDefaultTooltip a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setDefaultTooltip'_ a1' a2' >>= \res ->
  return ()
{-# LINE 240 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the system default TooltipWindow - Details: System will internally attempt to create an instance of the specified window type (which must be
--derived from the base Tooltip class).  If the Tooltip creation fails, the error is logged and no
--system default Tooltip will be available.
--
setDefaultTooltip2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ tooltipType
  ->  IO ()
 -- ^ 
setDefaultTooltip2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setDefaultTooltip2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 245 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | return a poiter to the system default tooltip. May return 0. 
getDefaultTooltip :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the current system default tooltip. May return 0 if no system default tooltip is available.     
getDefaultTooltip a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getDefaultTooltip'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 250 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Internal method to directly set the current modal target.  - Details: This method is called internally by Window
setModalTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ target
  ->  IO ()
 -- ^ 
setModalTarget a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setModalTarget'_ a1' a2' >>= \res ->
  return ()
{-# LINE 255 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Return a pointer to the Window
getModalTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the current modal target. NULL if there is no modal target.     
getModalTarget a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getModalTarget'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 260 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Perform updates with regards to the window that contains the mouse cursor, firing any required MouseEnters / MouseLeaves events.  - Details: The CEGUI
updateWindowContainingMouse :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
updateWindowContainingMouse a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  updateWindowContainingMouse'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 265 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Retrieve the image codec to be used by the system. 
getImageCodec :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getImageCodec a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getImageCodec'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 270 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the image codec to be used by the system. 
setImageCodec :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ codecName
  ->  IO ()
 -- ^ 
setImageCodec a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setImageCodec'_ a1' a2' >>= \res ->
  return ()
{-# LINE 275 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Set the image codec to use from an existing image codec.  - Details: In this case the renderer does not take the ownership of the image codec
--object.
--
setImageCodec2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ codec
  ->  IO ()
 -- ^ 
setImageCodec2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setImageCodec2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 280 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Invalidate all imagery and geometry caches for CEGUI - Details: This function will invalidate the caches used for both imagery and geometry for all content that is managed by the core CEGUIWindow
invalidateAllCachedRendering :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
invalidateAllCachedRendering a1 =
  withHG3DClass a1 $ \a1' -> 
  invalidateAllCachedRendering'_ a1' >>= \res ->
  return ()
{-# LINE 284 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a mouse movement event into the system. 
injectMouseMove :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ delta_x - amount the mouse moved on the x axis.
  ->  Float  -- ^ delta_y - amount the mouse moved on the y axis.
  ->  IO (Bool)
 -- ^ 
injectMouseMove a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  alloca $ \a4' -> 
  injectMouseMove'_ a1' a2' a3' a4' >>= \res ->
  peekBoolUtil  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 291 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects that the mouse has left the application window. 
injectMouseLeaves :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
injectMouseLeaves a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  injectMouseLeaves'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 296 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a mouse button down event into the system. 
injectMouseButtonDown :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumMouseButton  -- ^ button - One of the MouseButton values indicating which button was pressed.
  ->  IO (Bool)
 -- ^ 
injectMouseButtonDown a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  injectMouseButtonDown'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 302 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a mouse button up event into the system. 
injectMouseButtonUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumMouseButton  -- ^ button - One of the MouseButton values indicating which button was released.
  ->  IO (Bool)
 -- ^ 
injectMouseButtonUp a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  injectMouseButtonUp'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 308 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a key down event into the system. 
injectKeyDown :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ key_code - uint value indicating which key was pressed.
  ->  IO (Bool)
 -- ^ 
injectKeyDown a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  injectKeyDown'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 314 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a key up event into the system. 
injectKeyUp :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ key_code - uint value indicating which key was released.
  ->  IO (Bool)
 -- ^ 
injectKeyUp a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  injectKeyUp'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 320 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a typed character event into the system. 
injectChar :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ code_point - Unicode code point of the character that was typed.
  ->  IO (Bool)
 -- ^ 
injectChar a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  injectChar'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 326 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a mouse-wheel / scroll-wheel event into the system. 
injectMouseWheelChange :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ delta - float value representing the amount the wheel moved.
  ->  IO (Bool)
 -- ^ 
injectMouseWheelChange a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  alloca $ \a3' -> 
  injectMouseWheelChange'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 332 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method that injects a new position for the mouse cursor. 
injectMousePosition :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ x_pos - New absolute pixel position of the mouse cursor on the x axis.
  ->  Float  -- ^ y_pos - New absolute pixel position of the mouse cursoe in the y axis.
  ->  IO (Bool)
 -- ^ 
injectMousePosition a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  let {a3' = realToFrac a3} in 
  alloca $ \a4' -> 
  injectMousePosition'_ a1' a2' a3' a4' >>= \res ->
  peekBoolUtil  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 339 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Method to inject time pulses into the system. 
injectTimePulse :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ timeElapsed - float value indicating the amount of time passed, in seconds, since the last time this method was called.
  ->  IO (Bool)
 -- ^ return value - Currently, this method always returns true.     
injectTimePulse a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  alloca $ \a3' -> 
  injectTimePulse'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 345 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Function to directly inject a mouse button click event.  - Details: Here 'click' means a mouse button down event followed by a mouse
--button up event.
--
injectMouseButtonClick :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumMouseButton  -- ^ button
  ->  IO (Bool)
 -- ^ 
injectMouseButtonClick a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  injectMouseButtonClick'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 351 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Function to directly inject a mouse button double-click event.  - Details: Here 'double-click' means a single mouse button had the sequence down,
--up, down within a predefined period of time.
--
injectMouseButtonDoubleClick :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumMouseButton  -- ^ button
  ->  IO (Bool)
 -- ^ 
injectMouseButtonDoubleClick a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  injectMouseButtonDoubleClick'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 357 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}

-- | Function to directly inject a mouse button triple-click event.  - Details: Here 'triple-click' means a single mouse button had the sequence down,
--up, down, up, down within a predefined period of time.
--
injectMouseButtonTripleClick :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumMouseButton  -- ^ button
  ->  IO (Bool)
 -- ^ 
injectMouseButtonTripleClick a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  alloca $ \a3' -> 
  injectMouseButtonTripleClick'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 363 ".\\HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs" #-}


foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_create"
  create'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ())))))))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_destroy"
  destroy'_ :: (IO ())

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getSingleton"
  getSingleton'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getSingletonPtr"
  getSingletonPtr'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultXMLParserName"
  setDefaultXMLParserName'_ :: ((Ptr CChar) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getDefaultXMLParserName"
  getDefaultXMLParserName'_ :: ((Ptr CChar) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultImageCodecName"
  setDefaultImageCodecName'_ :: ((Ptr CChar) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getDefaultImageCodecName"
  getDefaultImageCodecName'_ :: ((Ptr CChar) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getRenderer"
  getRenderer'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultFont"
  setDefaultFont'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultFont2"
  setDefaultFont2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getDefaultFont"
  getDefaultFont'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_signalRedraw"
  signalRedraw'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_isRedrawRequested"
  isRedrawRequested'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_renderGUI"
  renderGUI'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setGUISheet"
  setGUISheet'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getGUISheet"
  getGUISheet'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getSingleClickTimeout"
  getSingleClickTimeout'_ :: ((HG3DClassPtr) -> ((Ptr CDouble) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getMultiClickTimeout"
  getMultiClickTimeout'_ :: ((HG3DClassPtr) -> ((Ptr CDouble) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setSingleClickTimeout"
  setSingleClickTimeout'_ :: ((HG3DClassPtr) -> (CDouble -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setMultiClickTimeout"
  setMultiClickTimeout'_ :: ((HG3DClassPtr) -> (CDouble -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_isMouseClickEventGenerationEnabled"
  isMouseClickEventGenerationEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setMouseClickEventGenerationEnabled"
  setMouseClickEventGenerationEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultMouseCursor3"
  setDefaultMouseCursor3'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getWindowContainingMouse"
  getWindowContainingMouse'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getScriptingModule"
  getScriptingModule'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setScriptingModule"
  setScriptingModule'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getResourceProvider"
  getResourceProvider'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_executeScriptFile"
  executeScriptFile'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_executeScriptGlobal"
  executeScriptGlobal'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_executeScriptString"
  executeScriptString'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getMouseMoveScaling"
  getMouseMoveScaling'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setMouseMoveScaling"
  setMouseMoveScaling'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_notifyWindowDestroyed"
  notifyWindowDestroyed'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getSystemKeys"
  getSystemKeys'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setXMLParser"
  setXMLParser'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setXMLParser2"
  setXMLParser2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getXMLParser"
  getXMLParser'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultTooltip"
  setDefaultTooltip'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setDefaultTooltip2"
  setDefaultTooltip2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getDefaultTooltip"
  getDefaultTooltip'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setModalTarget"
  setModalTarget'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getModalTarget"
  getModalTarget'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_updateWindowContainingMouse"
  updateWindowContainingMouse'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_getImageCodec"
  getImageCodec'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setImageCodec"
  setImageCodec'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_setImageCodec2"
  setImageCodec2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_invalidateAllCachedRendering"
  invalidateAllCachedRendering'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseMove"
  injectMouseMove'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> ((Ptr CInt) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseLeaves"
  injectMouseLeaves'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseButtonDown"
  injectMouseButtonDown'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseButtonUp"
  injectMouseButtonUp'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectKeyDown"
  injectKeyDown'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectKeyUp"
  injectKeyUp'_ :: ((HG3DClassPtr) -> (CUInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectChar"
  injectChar'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseWheelChange"
  injectMouseWheelChange'_ :: ((HG3DClassPtr) -> (CFloat -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMousePosition"
  injectMousePosition'_ :: ((HG3DClassPtr) -> (CFloat -> (CFloat -> ((Ptr CInt) -> (IO ())))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectTimePulse"
  injectTimePulse'_ :: ((HG3DClassPtr) -> (CFloat -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseButtonClick"
  injectMouseButtonClick'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseButtonDoubleClick"
  injectMouseButtonDoubleClick'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassSystem.chs.h cegui_sstm_injectMouseButtonTripleClick"
  injectMouseButtonTripleClick'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))