-- 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\\ClassWindow.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.
-- 


-- ClassWindow.chs

-- 

module HGamer3D.Bindings.CEGUI.ClassWindow 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\\ClassWindow.chs" #-}
import HGamer3D.Bindings.CEGUI.ClassPtr
{-# LINE 41 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}
import HGamer3D.Bindings.CEGUI.StructHG3DClass
{-# LINE 42 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}
import HGamer3D.Bindings.CEGUI.EnumVerticalAlignment
{-# LINE 43 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}
import HGamer3D.Bindings.CEGUI.EnumHorizontalAlignment
{-# LINE 44 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}
import HGamer3D.Bindings.CEGUI.EnumWindowUpdateMode
{-# LINE 45 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Constructor for Window
new :: String  -- ^ type - String object holding Window type (usually provided by WindowFactory).
  ->  String  -- ^ name - String object holding unique name for the Window. 
  ->  IO (HG3DClass)
 -- ^ 
new a1 a2 =
  withCString a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  new'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 52 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Destructor for Window
delete :: HG3DClass  -- ^ classpointer - pointer of Class instance which is going to be deleted.
  ->  IO ()
 -- ^ 
delete a1 =
  withHG3DClass a1 $ \a1' -> 
  delete'_ a1' >>= \res ->
  return ()
{-# LINE 56 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a String object holding the type name for this Window
getType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - String object holding the     
getType a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getType'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 61 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a String object holding the name of this Window
getName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - String object holding the unique     
getName a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getName'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 66 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | returns whether or not this Window
isDestroyedByParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isDestroyedByParent a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isDestroyedByParent'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 71 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | returns whether or not this WindowWindow
isAlwaysOnTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isAlwaysOnTop a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isAlwaysOnTop'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 76 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return whether the Window
isDisabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ localOnly - States whether to only return the state set for this window, and not to factor in inherited state from ancestor windows.
  ->  IO (Bool)
 -- ^ 
isDisabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  alloca $ \a3' -> 
  isDisabled'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 82 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if the Window - Details: When true is returned from this function does not mean that the window
--is not completely obscured by other windows, just that the window will
--be processed when rendering, and is not explicitly marked as hidden.
--
isVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ localOnly
  ->  IO (Bool)
 -- ^ 
isVisible a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  alloca $ \a3' -> 
  isVisible'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 88 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if this is the active Window - Details: Mouse events are always sent to the window containing the mouse cursor
--regardless of what this function reports (unless a window has captured
--inputs).  The active state mainly determines where send other, for
--example keyboard, inputs.
--
isActive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isActive a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isActive'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 93 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if this WindowWindow
isClippedByParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isClippedByParent a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isClippedByParent'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 98 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the ID code currently assigned to this Window
getID :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ return value - uint value equal to the currently assigned ID code for this     
getID a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getID'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 103 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the number of child WindowWindow
getChildCount :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ return value - size_t value equal to the number of     
getChildCount a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getChildCount'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 108 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | returns whether a WindowWindow
isChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object containing the name of the Window to look for.
  ->  IO (Bool)
 -- ^ 
isChild a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  isChild'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 114 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | returns whether at least one window with the given ID code is attached to this Window - Details: ID codes are client assigned and may or may not be unique, and as such, the return from this function will only have meaning to the client code.
isChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID - uint ID code to look for.
  ->  IO (Bool)
 -- ^ 
isChild2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  isChild2'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 120 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | returns whether at least one window with the given ID code is attached to this Window - Details: ID codes are client assigned and may or may not be unique, and as such, the return from this function will only have meaning to the client code.
isChildRecursive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID
  ->  IO (Bool)
 -- ^ 
isChildRecursive a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  isChildRecursive'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 126 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if the given Window
isChild3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ window - Pointer to the Window object to look for.
  ->  IO (Bool)
 -- ^ 
isChild3 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  isChild3'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 132 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the child window with the specified name.  - Details: This function will throw an exception if no child object with the given
--name is attached.  This decision was made (over returning NULL if no
--window was found) so that client code can assume that if the call
--returns it has a valid window pointer.  We provide the isChild()
--functions for checking if a given window is attached.
--
getChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
getChild a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  getChild'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 138 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the first attached child window with the specified ID value.  - Details: This function will throw an exception if no child object with the given
--ID is attached.  This decision was made (over returning NULL if no
--window was found) so that client code can assume that if the call
--returns it has a valid window pointer.  We provide the isChild()
--functions for checking if a given window is attached.
--
getChild2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID
  ->  IO (HG3DClass)
 -- ^ 
getChild2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  getChild2'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 144 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the first attached child window with the specified name. Children are traversed recursively.  - Details: Contrary to the non recursive version of this function, this one will
--not throw an exception, but return 0 in case no child was found.
--
getChildRecursive :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name
  ->  IO (HG3DClass)
 -- ^ 
getChildRecursive a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  getChildRecursive'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 150 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the first attached child window with the specified ID value. Children are traversed recursively.  - Details: Contrary to the non recursive version of this function, this one will
--not throw an exception, but return 0 in case no child was found.
--
getChildRecursive2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID
  ->  IO (HG3DClass)
 -- ^ 
getChildRecursive2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  getChildRecursive2'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 156 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the child window that is attached to 'this' at the given index. 
getChildAtIdx :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ idx - Index of the child window whos pointer should be returned. This value is not bounds checked, client code should ensure that this is less than the value returned by getChildCount().
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the child window currently attached at index position     
getChildAtIdx a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  getChildAtIdx'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 162 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return a pointer to the WindowWindow
getActiveChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the window that is active (has input focus) starting at this window. The function will return 'this' if this     
getActiveChild a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActiveChild'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 167 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

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

-- | return true if the specified WindowWindow
isAncestor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the Window to check for.
  ->  IO (Bool)
 -- ^ 
isAncestor a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  isAncestor'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 178 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if any WindowWindow
isAncestor2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID - uint value specifying the ID to look for.
  ->  IO (Bool)
 -- ^ 
isAncestor2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  alloca $ \a3' -> 
  isAncestor2'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 184 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if the specified WindowWindow
isAncestor3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ window - Pointer to the Window object to look for.
  ->  IO (Bool)
 -- ^ 
isAncestor3 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  isAncestor3'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 190 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the active FontWindow
getFont :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ useDefault - Sepcifies whether to return the default font if this Window has no preferred font set.
  ->  IO (HG3DClass)
 -- ^ return value - Pointer to the     
getFont a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  alloca $ \a3' -> 
  getFont'_ a1' a2' a3' >>= \res ->
  peek  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 196 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the current text for the Window
getText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - The String object that holds the current text for this     
getText a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getText'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 201 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return text string with visual
getTextVisual :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ 
getTextVisual a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getTextVisual'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 206 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if the Window
inheritsAlpha :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
inheritsAlpha a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  inheritsAlpha'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 211 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the current alpha value set for this Window - Details: The alpha value set for any given window may or may not be the final alpha value that is used when rendering. All window objects, by default, inherit alpha from thier parent window(s) - this will blend child windows, relatively, down the line of inheritance. This behaviour can be overridden via the setInheritsAlpha()getEffectiveAlpha()
getAlpha :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - the currently set alpha value for this     
getAlpha a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAlpha'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 216 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the effective alpha value that will be used when rendering this window, taking into account inheritance of parent window(s) alpha. 
getEffectiveAlpha :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - the effective alpha that will be applied to this     
getEffectiveAlpha a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getEffectiveAlpha'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 221 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if this Window
isCapturedByThis :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCapturedByThis a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCapturedByThis'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 226 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if an ancestor window has captured inputs. 
isCapturedByAncestor :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCapturedByAncestor a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCapturedByAncestor'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 231 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return true if a child window has captured inputs. 
isCapturedByChild :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isCapturedByChild a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isCapturedByChild'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 236 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

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

-- | Return whether this window is set to restore old input capture when it loses input capture.  - Details: This is only really useful for certain sub-components for widget
--writers.
--
restoresOldCapture :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
restoresOldCapture a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  restoresOldCapture'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 246 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether z-order changes are enabled or disabled for this Window - Details: This is distinguished from the is/setRiseOnClickEnabled setting in that if rise on click is disabled it only affects the users ability to affect the z order of the WindowWindowWindow
isZOrderingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isZOrderingEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isZOrderingEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 251 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether this window will receive multi-click events or multiple 'down' events instead. 
wantsMultiClickEvents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
wantsMultiClickEvents a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  wantsMultiClickEvents'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 256 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether mouse button down event autorepeat is enabled for this window. 
isMouseAutoRepeatEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isMouseAutoRepeatEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isMouseAutoRepeatEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 261 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the current auto-repeat delay setting for this window. 
getAutoRepeatDelay :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - float value indicating the delay, in seconds, defore the first repeat mouse button down event will be triggered when autorepeat is enabled.     
getAutoRepeatDelay a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAutoRepeatDelay'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 266 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the current auto-repeat rate setting for this window. 
getAutoRepeatRate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - float value indicating the rate, in seconds, at which repeat mouse button down events will be generated after the initial delay has expired.     
getAutoRepeatRate a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getAutoRepeatRate'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 271 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether the window wants inputs passed to its attached child windows when the window has inputs captured. 
distributesCapturedInputs :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
distributesCapturedInputs a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  distributesCapturedInputs'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 276 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether this WindowTooltipTooltip
isUsingDefaultTooltip :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isUsingDefaultTooltip a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isUsingDefaultTooltip'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 281 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

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

-- | Return the custom tooltip type. 
getTooltipType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - String object holding the current custom tooltip window type, or an empty string if no custom tooltip is set.     
getTooltipType a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getTooltipType'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 291 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the current tooltip text set for this Window
getTooltipText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - String object holding the current tooltip text set for this window.     
getTooltipText a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getTooltipText'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 296 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether this window inherits Tooltip
inheritsTooltipText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
inheritsTooltipText a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  inheritsTooltipText'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 301 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether this window will rise to the top of the z-order when clicked with the left mouse button.  - Details: This is distinguished from the is/setZOrderingEnabled setting in that if rise on click is disabled it only affects the users ability to affect the z order of the WindowWindowWindow
isRiseOnClickEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isRiseOnClickEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isRiseOnClickEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 306 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether this window was inherited from the given class name at some point in the inheritance hierarchy. 
testClassName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ class_name - The class name that is to be checked.
  ->  IO (Bool)
 -- ^ return value - true if this window was inherited from     
testClassName a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  testClassName'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 312 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Get the vertical alignment.  - Details: Returns the vertical alignment for the window.  This setting affects how
--the windows position is interpreted relative to its parent.
--
getVerticalAlignment :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumVerticalAlignment)
 -- ^ 
getVerticalAlignment a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getVerticalAlignment'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 317 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Get the horizontal alignment.  - Details: Returns the horizontal alignment for the window.  This setting affects
--how the windows position is interpreted relative to its parent.
--
getHorizontalAlignment :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumHorizontalAlignment)
 -- ^ 
getHorizontalAlignment a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getHorizontalAlignment'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 322 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Get the name of the LookNFeel assigned to this window. 
getLookNFeel :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - String object holding the name of the look assigned to this window. Returns the empty string if no look is assigned.     
getLookNFeel a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getLookNFeel'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 327 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Get whether or not this Window
getModalState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ return value - Returns true if this     
getModalState a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getModalState'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 332 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns a named user string. 
getUserString :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the string to be returned.
  ->  IO (String)
 -- ^ return value - String object holding the data stored for the requested user string.    
getUserString a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloc64k $ \a3' -> 
  getUserString'_ a1' a2' a3' >>= \res ->
  peekCString  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 338 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether a user string with the specified name exists. 
isUserStringDefined :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the string to be checked.
  ->  IO (Bool)
 -- ^ 
isUserStringDefined a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  isUserStringDefined'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 344 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns the active sibling window.  - Details: This searches the immediate children of this window's parent, and
--returns a pointer to the active window.  The method will return this if
--we are the immediate child of our parent that is active.  If our parent
--is not active, or if no immediate child of our parent is active then 0
--is returned.  If this window has no parent, and this window is not
--active then 0 is returned, else this is returned.
--
getActiveSibling :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ 
getActiveSibling a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getActiveSibling'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 349 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the pixel Width of the parent element. This always returns a valid number. 
getParentPixelWidth :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - float value that is equal to the pixel width of this     
getParentPixelWidth a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getParentPixelWidth'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 354 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the pixel Height of the parent element. This always returns a valid number. 
getParentPixelHeight :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Float)
 -- ^ return value - float value that is equal to the pixel height of this     
getParentPixelHeight a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getParentPixelHeight'_ a1' a2' >>= \res ->
  peekFloatConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 359 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns whether this window should ignore mouse event and pass them through to and other windows behind it. In effect making the window transparent to the mouse. 
isMousePassThroughEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ return value - true if mouse pass through is enabled. false if mouse pass through is not enabled.     
isMousePassThroughEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isMousePassThroughEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 364 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns whether this window is an auto-child window. All auto-child windows have "__auto_" in their name, but this is faster. 
isAutoWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isAutoWindow a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isAutoWindow'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 369 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns whether this window is allowed to write XML. 
isWritingXMLAllowed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isWritingXMLAllowed a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isWritingXMLAllowed'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 374 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns whether this Window
isDragDropTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isDragDropTarget a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isDragDropTarget'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 379 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns whether automatic
isUsingAutoRenderingSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isUsingAutoRenderingSurface a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isUsingAutoRenderingSurface'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 384 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Returns the window at the root of the hierarchy starting at this Window
getRootWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (HG3DClass)
 -- ^ return value - A pointer to the root window of the hierarchy that this window is attched to.     
getRootWindow a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getRootWindow'_ a1' a2' >>= \res ->
  peek  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 389 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

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

-- | Return whether the Window - Details: A non-client window is clipped, positioned and sized according to the
--parent window's full area as opposed to just the inner rect area used
--for normal client windows.
--
isNonClientWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isNonClientWindow a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isNonClientWindow'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 399 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Renames the window. 
rename :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ new_name - String object holding the new name for the window.
  ->  IO ()
 -- ^ 
rename a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  rename'_ a1' a2' >>= \res ->
  return ()
{-# LINE 404 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Initialises the Window - Details: This must be called for every window created. Normally this is handled automatically by the WindowManager
initialiseComponents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
initialiseComponents a1 =
  withHG3DClass a1 $ \a1' -> 
  initialiseComponents'_ a1' >>= \res ->
  return ()
{-# LINE 408 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether or not this WindowWindow
setDestroyedByParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setDestroyedByParent a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setDestroyedByParent'_ a1' a2' >>= \res ->
  return ()
{-# LINE 413 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window is always on top, or not. 
setAlwaysOnTop :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setAlwaysOnTop a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setAlwaysOnTop'_ a1' a2' >>= \res ->
  return ()
{-# LINE 418 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window is enabled or disabled. A disabled window normally can not be interacted with, and may have different rendering. 
setEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 423 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | enable the Window
enable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
enable a1 =
  withHG3DClass a1 $ \a1' -> 
  enable'_ a1' >>= \res ->
  return ()
{-# LINE 427 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | disable the Window
disable :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
disable a1 =
  withHG3DClass a1 $ \a1' -> 
  disable'_ a1' >>= \res ->
  return ()
{-# LINE 431 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether the Window - Details: Hiding the active window will cause that window to become deactivated. Showing a window does not, however, automatically cause that window to become the active window (call Window::activate
setVisible :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setVisible a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setVisible'_ a1' a2' >>= \res ->
  return ()
{-# LINE 436 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | show the Window - Details: Showing a window does not automatically activate the window. If you want the window to also become active you will need to call the Window::activate
show :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
show a1 =
  withHG3DClass a1 $ \a1' -> 
  show'_ a1' >>= \res ->
  return ()
{-# LINE 440 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | hide the Window - Details: If the window is the active window, it will become deactivated as a result of being hidden.
hide :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
hide a1 =
  withHG3DClass a1 $ \a1' -> 
  hide'_ a1' >>= \res ->
  return ()
{-# LINE 444 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Activate the WindowWindow
activate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
activate a1 =
  withHG3DClass a1 $ \a1' -> 
  activate'_ a1' >>= \res ->
  return ()
{-# LINE 448 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Deactivate the window. No further inputs will be received by the window until it is re-activated either programmatically or by the user interacting with the gui. 
deactivate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing.     
deactivate a1 =
  withHG3DClass a1 $ \a1' -> 
  deactivate'_ a1' >>= \res ->
  return ()
{-# LINE 452 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this Window
setClippedByParent :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setClippedByParent a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setClippedByParent'_ a1' a2' >>= \res ->
  return ()
{-# LINE 457 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the current ID for the Window
setID :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID - Client assigned ID code for this Window. The GUI system assigns no meaning to any IDs, they are a device purely for client code usage.
  ->  IO ()
 -- ^ return value - Nothing     
setID a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  setID'_ a1' a2' >>= \res ->
  return ()
{-# LINE 462 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the current text string for the Window
setText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ text - String object containing the text that is to be set as the Window text.
  ->  IO ()
 -- ^ return value - Nothing     
setText a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setText'_ a1' a2' >>= \res ->
  return ()
{-# LINE 467 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Append the string textWindow
appendText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ text - String object holding the text that is to be appended to the Window object's current text string. 
  ->  IO ()
 -- ^ 
appendText a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  appendText'_ a1' a2' >>= \res ->
  return ()
{-# LINE 472 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the font used by this Window
setFont :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ font - Pointer to the Font object to be used by this Window. If font is NULL, the default font will be used.
  ->  IO ()
 -- ^ return value - Nothing     
setFont a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setFont'_ a1' a2' >>= \res ->
  return ()
{-# LINE 477 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the font used by this Window
setFont2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the Font object to be used by this Window. If name == "", the default font will be used.
  ->  IO ()
 -- ^ return value - Nothing    
setFont2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setFont2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 482 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Add the named WindowWindowWindownameWindowWindow
addChildWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the Window to be added.
  ->  IO ()
 -- ^ return value - Nothing.    
addChildWindow a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  addChildWindow'_ a1' a2' >>= \res ->
  return ()
{-# LINE 487 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Add the specified WindowWindowWindowwindowWindowWindow
addChildWindow2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ window - Pointer to the Window object to be added.
  ->  IO ()
 -- ^ return value - Nothing    
addChildWindow2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  addChildWindow2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 492 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Remove the named Window
removeChildWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the Window to be removed. If the Window specified is not attached to this Window, nothing happens.
  ->  IO ()
 -- ^ return value - Nothing.     
removeChildWindow a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  removeChildWindow'_ a1' a2' >>= \res ->
  return ()
{-# LINE 497 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Remove the specified Window
removeChildWindow2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ window - Pointer to the Window object to be removed. If the window is not attached to this Window, then nothing happens.
  ->  IO ()
 -- ^ return value - Nothing.     
removeChildWindow2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  removeChildWindow2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 502 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Remove the first child WindowWindow
removeChildWindow3 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Int  -- ^ ID - ID number assigned to the Window to be removed. If no Window with ID code ID is attached, nothing happens.
  ->  IO ()
 -- ^ return value - Nothing.     
removeChildWindow3 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromIntegral a2} in 
  removeChildWindow3'_ a1' a2' >>= \res ->
  return ()
{-# LINE 507 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Move the Window - Details: - If the Window is a non always-on-top window it is moved the the top of
--  all other non always-on-top sibling windows, and the process repeated
--  for all ancestors.
--- If the Window is an always-on-top window it is moved to the of of all
--  sibling Windows, and the process repeated for all ancestors.
--
moveToFront :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
moveToFront a1 =
  withHG3DClass a1 $ \a1' -> 
  moveToFront'_ a1' >>= \res ->
  return ()
{-# LINE 511 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Move the Window - Details: - If the window is non always-on-top the Window is sent to the very
--  bottom of its sibling windows and the process repeated for all
--  ancestors.
--- If the window is always-on-top, the Window is sent to the bottom of
--  all sibling always-on-top windows and the process repeated for all
--  ancestors.
--
moveToBack :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
moveToBack a1 =
  withHG3DClass a1 $ \a1' -> 
  moveToBack'_ a1' >>= \res ->
  return ()
{-# LINE 515 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Captures input to this window. 
captureInput :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
captureInput a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  captureInput'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 520 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Releases input capture from this WindowWindow
releaseInput :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
releaseInput a1 =
  withHG3DClass a1 $ \a1' -> 
  releaseInput'_ a1' >>= \res ->
  return ()
{-# LINE 524 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window will remember and restore the previous window that had inputs captured.  - Details: 
--
setRestoreCapture :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ 
setRestoreCapture a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setRestoreCapture'_ a1' a2' >>= \res ->
  return ()
{-# LINE 529 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the current alpha value for this window.  - Details: The alpha value set for any given window may or may not be the final alpha value that is used when rendering. All window objects, by default, inherit alpha from thier parent window(s) - this will blend child windows, relatively, down the line of inheritance. This behaviour can be overridden via the setInheritsAlpha()getEffectiveAlpha()
setAlpha :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ alpha - The new alpha value for the window. Value should be between 0.0f and 1.0f.
  ->  IO ()
 -- ^ return value - Nothing     
setAlpha a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setAlpha'_ a1' a2' >>= \res ->
  return ()
{-# LINE 534 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets whether this Window
setInheritsAlpha :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing     
setInheritsAlpha a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setInheritsAlpha'_ a1' a2' >>= \res ->
  return ()
{-# LINE 539 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Invalidate this window causing at least this window to be redrawn during the next rendering pass. 
invalidate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing    
invalidate a1 =
  withHG3DClass a1 $ \a1' -> 
  invalidate'_ a1' >>= \res ->
  return ()
{-# LINE 543 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Invalidate this window and - dependant upon recursive
invalidate2 :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ recursive - Boolean value indicating whether attached child content should also be invalidated.
--
--
  ->  IO ()
 -- ^ return value - Nothing     
invalidate2 a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  invalidate2'_ a1' a2' >>= \res ->
  return ()
{-# LINE 548 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the mouse cursor image to be used when the mouse enters this window. 
setMouseCursor3 :: 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.    
setMouseCursor3 a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withCString a3 $ \a3' -> 
  setMouseCursor3'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 554 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether z-order changes are enabled or disabled for this Window - Details: This is distinguished from the is/setRiseOnClickEnabled setting in that if rise on click is disabled it only affects the users ability to affect the z order of the WindowWindowWindow
setZOrderingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setZOrderingEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setZOrderingEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 559 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window will receive multi-click events or multiple 'down' events instead. 
setWantsMultiClickEvents :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setWantsMultiClickEvents a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setWantsMultiClickEvents'_ a1' a2' >>= \res ->
  return ()
{-# LINE 564 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether mouse button down event autorepeat is enabled for this window. 
setMouseAutoRepeatEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setMouseAutoRepeatEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setMouseAutoRepeatEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 569 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the current auto-repeat delay setting for this window. 
setAutoRepeatDelay :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ delay - float value indicating the delay, in seconds, defore the first repeat mouse button down event should be triggered when autorepeat is enabled.
  ->  IO ()
 -- ^ return value - Nothing.     
setAutoRepeatDelay a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setAutoRepeatDelay'_ a1' a2' >>= \res ->
  return ()
{-# LINE 574 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the current auto-repeat rate setting for this window. 
setAutoRepeatRate :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ rate - float value indicating the rate, in seconds, at which repeat mouse button down events should be generated after the initial delay has expired.
  ->  IO ()
 -- ^ return value - Nothing.     
setAutoRepeatRate a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  setAutoRepeatRate'_ a1' a2' >>= \res ->
  return ()
{-# LINE 579 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether the window wants inputs passed to its attached child windows when the window has inputs captured. 
setDistributesCapturedInputs :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ 
setDistributesCapturedInputs a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setDistributesCapturedInputs'_ a1' a2' >>= \res ->
  return ()
{-# LINE 584 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Internal support method for drag & drop. You do not normally call this directly from client code. See the DragContainer
notifyDragDropItemEnters :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ item
  ->  IO ()
 -- ^ 
notifyDragDropItemEnters a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  notifyDragDropItemEnters'_ a1' a2' >>= \res ->
  return ()
{-# LINE 589 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Internal support method for drag & drop. You do not normally call this directly from client code. See the DragContainer
notifyDragDropItemLeaves :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ item
  ->  IO ()
 -- ^ 
notifyDragDropItemLeaves a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  notifyDragDropItemLeaves'_ a1' a2' >>= \res ->
  return ()
{-# LINE 594 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Internal support method for drag & drop. You do not normally call this directly from client code. See the DragContainer
notifyDragDropItemDropped :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ item
  ->  IO ()
 -- ^ 
notifyDragDropItemDropped a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  notifyDragDropItemDropped'_ a1' a2' >>= \res ->
  return ()
{-# LINE 599 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Internal destroy method which actually just adds the window and any parent destructed child windows to the dead pool.  - Details: This is virtual to allow for specialised cleanup which may be required
--in some advanced cases.  If you override this for the above reason, you
--MUST call this base class version.
--
destroy :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
destroy a1 =
  withHG3DClass a1 $ \a1' -> 
  destroy'_ a1' >>= \res ->
  return ()
{-# LINE 603 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the custom TooltipWindowWindowTooltip
setTooltip :: 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 tooltip for this Window, or 0 to indicate that the Window should use the system default Tooltip object. Note that when passing a pointer to a Tooltip object, ownership of the Tooltip does not pass to this Window object.
  ->  IO ()
 -- ^ return value - Nothing.     
setTooltip a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  setTooltip'_ a1' a2' >>= \res ->
  return ()
{-# LINE 608 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the custom TooltipWindowWindow - Details: The Window 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 the
--Window will revert to using either the existing custom Tooltip or the
--system default Tooltip.
--
setTooltipType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ tooltipType
  ->  IO ()
 -- ^ 
setTooltipType a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setTooltipType'_ a1' a2' >>= \res ->
  return ()
{-# LINE 613 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the tooltip text for this window. 
setTooltipText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ tip - String object holding the text to be displayed in the tooltip for this Window.
  ->  IO ()
 -- ^ return value - Nothing.     
setTooltipText a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setTooltipText'_ a1' a2' >>= \res ->
  return ()
{-# LINE 618 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window inherits Tooltip
setInheritsTooltipText :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setInheritsTooltipText a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setInheritsTooltipText'_ a1' a2' >>= \res ->
  return ()
{-# LINE 623 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether this window will rise to the top of the z-order when clicked with the left mouse button.  - Details: This is distinguished from the is/setZOrderingEnabled setting in that if rise on click is disabled it only affects the users ability to affect the z order of the WindowWindowWindow
setRiseOnClickEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setRiseOnClickEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setRiseOnClickEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 628 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the vertical alignment.  - Details: Modifies the vertical alignment for the window.  This setting affects
--how the windows position is interpreted relative to its parent.
--
setVerticalAlignment :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumVerticalAlignment  -- ^ alignment
  ->  IO ()
 -- ^ 
setVerticalAlignment a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setVerticalAlignment'_ a1' a2' >>= \res ->
  return ()
{-# LINE 633 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the horizontal alignment.  - Details: Modifies the horizontal alignment for the window.  This setting affects
--how the windows position is interpreted relative to its parent.
--
setHorizontalAlignment :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumHorizontalAlignment  -- ^ alignment
  ->  IO ()
 -- ^ 
setHorizontalAlignment a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setHorizontalAlignment'_ a1' a2' >>= \res ->
  return ()
{-# LINE 638 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the LookNFeel that shoule be used for this window.  - Details: Once a look'n'feel has been assigned it is locked - as in cannot be changed. 
setLookNFeel :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ look - String object holding the name of the look to be assigned to the window.
  ->  IO ()
 -- ^ return value - Nothing.    
setLookNFeel a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setLookNFeel'_ a1' a2' >>= \res ->
  return ()
{-# LINE 643 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the modal state for this Window
setModalState :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ state - Boolean value defining if this Window should be the modal target.
--
--
  ->  IO ()
 -- ^ return value - Nothing.     
setModalState a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setModalState'_ a1' a2' >>= \res ->
  return ()
{-# LINE 648 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | method called to perform extended laying out of attached child windows.  - Details: The system may call this at various times (like when it is resized for
--example), and it may be invoked directly where required.
--
performChildWindowLayout :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
performChildWindowLayout a1 =
  withHG3DClass a1 $ \a1' -> 
  performChildWindowLayout'_ a1' >>= \res ->
  return ()
{-# LINE 652 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets the value a named user string, creating it as required. 
setUserString :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - String object holding the name of the string to be returned.
  ->  String  -- ^ value - String object holding the value to be assigned to the user string.
  ->  IO ()
 -- ^ return value - Nothing.     
setUserString a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withCString a3 $ \a3' -> 
  setUserString'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 658 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Causes the Window
render :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ return value - Nothing     
render a1 =
  withHG3DClass a1 $ \a1' -> 
  render'_ a1' >>= \res ->
  return ()
{-# LINE 662 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Cause window to update itself and any attached children. Client code does not need to call this method; to ensure full, and proper updates, call the injectTimePulse methodname method provided by the System - Details: The update order is such that 'this' window is updated prior to any child windows, this is so that child windows that access the parent in their update code get the correct updated state.
update :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Float  -- ^ elapsed - float value indicating the number of seconds passed since the last update.
  ->  IO ()
 -- ^ return value - Nothing.     
update a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = realToFrac a2} in 
  update'_ a1' a2' >>= \res ->
  return ()
{-# LINE 667 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets the internal 'initialising' flag to true. This can be use to optimize initialisation of some widgets, and is called automatically by the layout XML handler when it has created a window. That is just after the window has been created, but before any children or properties are read. 
beginInitialisation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
beginInitialisation a1 =
  withHG3DClass a1 $ \a1' -> 
  beginInitialisation'_ a1' >>= \res ->
  return ()
{-# LINE 671 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets the internal 'initialising' flag to false. This is called automatically by the layout XML handler when it is done creating a window. That is after all properties and children have been loaded and just before the next sibling gets created. 
endInitialisation :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
endInitialisation a1 =
  withHG3DClass a1 $ \a1' -> 
  endInitialisation'_ a1' >>= \res ->
  return ()
{-# LINE 675 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets whether this window should ignore mouse events and pass them through to any windows behind it. In effect making the window transparent to the mouse. 
setMousePassThroughEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - true if mouse pass through is enabled. false if mouse pass through is not enabled. 
  ->  IO ()
 -- ^ 
setMousePassThroughEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setMousePassThroughEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 680 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Assign the WindowRenderer to specify the Look'N'Feel specification to be used.  - Details: Once a window renderer has been assigned it is locked - as in cannot be changed. 
setWindowRenderer :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ name - The factory name of the WindowRenderer to use.
  ->  IO ()
 -- ^ 
setWindowRenderer a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  setWindowRenderer'_ a1' a2' >>= \res ->
  return ()
{-# LINE 685 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Get the factory name of the currently assigned WindowRenderer. (Look'N'Feel specification). 
getWindowRendererName :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (String)
 -- ^ return value - The factory name of the currently assigned WindowRenderer. If no WindowRenderer is assigned an empty string is returned.     
getWindowRendererName a1 =
  withHG3DClass a1 $ \a1' -> 
  alloc64k $ \a2' -> 
  getWindowRendererName'_ a1' a2' >>= \res ->
  peekCString  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 690 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets whether this window is allowed to write XML. 
setWritingXMLAllowed :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ allow
  ->  IO ()
 -- ^ 
setWritingXMLAllowed a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setWritingXMLAllowed'_ a1' a2' >>= \res ->
  return ()
{-# LINE 695 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Inform the window, and optionally all children, that screen area rectangles have changed. 
notifyScreenAreaChanged :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ recursive - 
--
--
  ->  IO ()
 -- ^ 
notifyScreenAreaChanged a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  notifyScreenAreaChanged'_ a1' a2' >>= \res ->
  return ()
{-# LINE 700 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Changes the widget's falagard type, thus changing its look'n'feel and optionally its renderer in the process. 
setFalagardType :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ type - New renderer of the widget 
  ->  String  -- ^ rendererType
  ->  IO ()
 -- ^ 
setFalagardType a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  withCString a3 $ \a3' -> 
  setFalagardType'_ a1' a2' a3' >>= \res ->
  return ()
{-# LINE 706 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Specifies whether this Window
setDragDropTarget :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ 
setDragDropTarget a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setDragDropTarget'_ a1' a2' >>= \res ->
  return ()
{-# LINE 711 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Invalidate the chain of rendering surfaces from this window backwards to ensure they get properly redrawn - but doing the minimum amount of work possibe - next render. 
invalidateRenderingSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO ()
 -- ^ 
invalidateRenderingSurface a1 =
  withHG3DClass a1 $ \a1' -> 
  invalidateRenderingSurface'_ a1' >>= \res ->
  return ()
{-# LINE 715 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Sets whether automatic - Details: Note that this setting really only controls whether the WindowuseWindowEnabling this option will cause the WindowWindowWindowbut not destroyedDisabling this option will cause any automatically created RenderingSurface to be released. It is possible that the renderer in use may not support facilities for RenderingSurfaces that are suitable for full imagery caching. If this is the case, then calling getRenderingSurface after enabling this option will return 0. In these cases this option will still show as being 'enabled', this is because WindowsettingsWindowIf this option is enabled, and the client subsequently assigns a different RenderingSurface to the Window
setUsingAutoRenderingSurface :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting - 
--
--
  ->  IO ()
 -- ^ 
setUsingAutoRenderingSurface a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setUsingAutoRenderingSurface'_ a1' a2' >>= \res ->
  return ()
{-# LINE 720 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether the Window - Details: A non-client window is clipped, positioned and sized according to the
--parent window's full area as opposed to just the inner rect area used
--for normal client windows.
--
setNonClientWindow :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting
  ->  IO ()
 -- ^ 
setNonClientWindow a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setNonClientWindow'_ a1' a2' >>= \res ->
  return ()
{-# LINE 725 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return whether text parsing is enabled for this window. 
isTextParsingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isTextParsingEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isTextParsingEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 730 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | set whether text parsing is enabled for this window. 
setTextParsingEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ setting
  ->  IO ()
 -- ^ 
setTextParsingEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setTextParsingEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 735 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Add the named property to the XML ban list for this window. 
banPropertyFromXML :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ property_name
  ->  IO ()
 -- ^ 
banPropertyFromXML a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  banPropertyFromXML'_ a1' a2' >>= \res ->
  return ()
{-# LINE 740 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Remove the named property from the XML ban list for this window. 
unbanPropertyFromXML :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ property_name
  ->  IO ()
 -- ^ 
unbanPropertyFromXML a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  unbanPropertyFromXML'_ a1' a2' >>= \res ->
  return ()
{-# LINE 745 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether the named property is banned from XML. 
isPropertyBannedFromXML :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ property_name
  ->  IO (Bool)
 -- ^ 
isPropertyBannedFromXML a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  alloca $ \a3' -> 
  isPropertyBannedFromXML'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 751 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set the window update mode. This mode controls the behaviour of the Window::update - Details: Disabling updates can have negative effects on the behaviour of CEGUI
setUpdateMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  EnumWindowUpdateMode  -- ^ mode - One of the WindowUpdateMode enumerated values indicating the mode to set for this Window. 
  ->  IO ()
 -- ^ 
setUpdateMode a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = cIntFromEnum a2} in 
  setUpdateMode'_ a1' a2' >>= \res ->
  return ()
{-# LINE 756 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the current window update mode that is set for this WindowWindow::update - Details: Disabling updates can have negative effects on the behaviour of CEGUI
getUpdateMode :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (EnumWindowUpdateMode)
 -- ^ return value - One of the WindowUpdateMode enumerated values indicating the current mode set for this     
getUpdateMode a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getUpdateMode'_ a1' a2' >>= \res ->
  peekEnumUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 761 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Set whether mouse input that is not directly handled by this WindowWindow
setMouseInputPropagationEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  Bool  -- ^ enabled - 
--
--
  ->  IO ()
 -- ^ 
setMouseInputPropagationEnabled a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  let {a2' = fromBool a2} in 
  setMouseInputPropagationEnabled'_ a1' a2' >>= \res ->
  return ()
{-# LINE 766 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether mouse input that is not directly handled by this WindowWindow
isMouseInputPropagationEnabled :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Bool)
 -- ^ 
isMouseInputPropagationEnabled a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  isMouseInputPropagationEnabled'_ a1' a2' >>= \res ->
  peekBoolUtil  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 771 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Clones this Window
clone :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  String  -- ^ newName - new name of the cloned window
  ->  Bool  -- ^ deepCopy - if true, even children are copied (the old name prefix will be replaced with new name prefix)
  ->  IO (HG3DClass)
 -- ^ return value - the cloned     
clone a1 a2 a3 =
  withHG3DClass a1 $ \a1' -> 
  withCString a2 $ \a2' -> 
  let {a3' = fromBool a3} in 
  alloca $ \a4' -> 
  clone'_ a1' a2' a3' a4' >>= \res ->
  peek  a4'>>= \a4'' -> 
  return (a4'')
{-# LINE 778 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | copies this widget's properties to given target widget 
clonePropertiesTo :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ target
  ->  IO ()
 -- ^ 
clonePropertiesTo a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  clonePropertiesTo'_ a1' a2' >>= \res ->
  return ()
{-# LINE 783 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | copies this widget's child widgets to given target widget 
cloneChildWidgetsTo :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ target
  ->  IO ()
 -- ^ 
cloneChildWidgetsTo a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  cloneChildWidgetsTo'_ a1' a2' >>= \res ->
  return ()
{-# LINE 788 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return the (visual) z index of the window on it's parent.  - Details: The z index is a number that indicates the order that windows will be drawn (but is not a 'z co-ordinate', as such). Higher numbers are in front of lower numbers.
getZIndex :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  IO (Int)
 -- ^ 
getZIndex a1 =
  withHG3DClass a1 $ \a1' -> 
  alloca $ \a2' -> 
  getZIndex'_ a1' a2' >>= \res ->
  peekIntConv  a2'>>= \a2'' -> 
  return (a2'')
{-# LINE 793 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether /a this Window - Details: Here 'in front' just means that one window is drawn after the other, it is not meant to imply that the windows are overlapping nor that one window is obscured by the other. 
isInFront :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ wnd
  ->  IO (Bool)
 -- ^ 
isInFront a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  isInFront'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 799 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | Return whether /a this Window - Details: Here 'behind' just means that one window is drawn before the other, it is not meant to imply that the windows are overlapping nor that one window is obscured by the other. 
isBehind :: HG3DClass  -- ^ classpointer - pointer of Class instance from which this methods is called.
  ->  HG3DClass  -- ^ wnd
  ->  IO (Bool)
 -- ^ 
isBehind a1 a2 =
  withHG3DClass a1 $ \a1' -> 
  withHG3DClass a2 $ \a2' -> 
  alloca $ \a3' -> 
  isBehind'_ a1' a2' a3' >>= \res ->
  peekBoolUtil  a3'>>= \a3'' -> 
  return (a3'')
{-# LINE 805 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}

-- | return the Window
getCaptureWindow :: IO (HG3DClass)
 -- ^ return value - Pointer to the     
getCaptureWindow =
  alloca $ \a1' -> 
  getCaptureWindow'_ a1' >>= \res ->
  peek  a1'>>= \a1'' -> 
  return (a1'')
{-# LINE 809 ".\\HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs" #-}


foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_construct"
  new'_ :: ((Ptr CChar) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_destruct"
  delete'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getType"
  getType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getName"
  getName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isDestroyedByParent"
  isDestroyedByParent'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isAlwaysOnTop"
  isAlwaysOnTop'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isDisabled"
  isDisabled'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isVisible"
  isVisible'_ :: ((HG3DClassPtr) -> (CInt -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isActive"
  isActive'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isClippedByParent"
  isClippedByParent'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getID"
  getID'_ :: ((HG3DClassPtr) -> ((Ptr CUInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChildCount"
  getChildCount'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

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

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isChild3"
  isChild3'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChild"
  getChild'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChild2"
  getChild2'_ :: ((HG3DClassPtr) -> (CUInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChildRecursive"
  getChildRecursive'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChildRecursive2"
  getChildRecursive2'_ :: ((HG3DClassPtr) -> (CUInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getChildAtIdx"
  getChildAtIdx'_ :: ((HG3DClassPtr) -> (CInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getActiveChild"
  getActiveChild'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getActiveChild2"
  getActiveChild2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

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

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isAncestor3"
  isAncestor3'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getFont"
  getFont'_ :: ((HG3DClassPtr) -> (CInt -> ((HG3DClassPtr) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getText"
  getText'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getTextVisual"
  getTextVisual'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_inheritsAlpha"
  inheritsAlpha'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getAlpha"
  getAlpha'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getEffectiveAlpha"
  getEffectiveAlpha'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isCapturedByThis"
  isCapturedByThis'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isCapturedByAncestor"
  isCapturedByAncestor'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isCapturedByChild"
  isCapturedByChild'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getParent"
  getParent'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_restoresOldCapture"
  restoresOldCapture'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isZOrderingEnabled"
  isZOrderingEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_wantsMultiClickEvents"
  wantsMultiClickEvents'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isMouseAutoRepeatEnabled"
  isMouseAutoRepeatEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getAutoRepeatDelay"
  getAutoRepeatDelay'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getAutoRepeatRate"
  getAutoRepeatRate'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_distributesCapturedInputs"
  distributesCapturedInputs'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isUsingDefaultTooltip"
  isUsingDefaultTooltip'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getTooltip"
  getTooltip'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getTooltipType"
  getTooltipType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getTooltipText"
  getTooltipText'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_inheritsTooltipText"
  inheritsTooltipText'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isRiseOnClickEnabled"
  isRiseOnClickEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getVerticalAlignment"
  getVerticalAlignment'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getHorizontalAlignment"
  getHorizontalAlignment'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getLookNFeel"
  getLookNFeel'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getModalState"
  getModalState'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getUserString"
  getUserString'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getActiveSibling"
  getActiveSibling'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getParentPixelWidth"
  getParentPixelWidth'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getParentPixelHeight"
  getParentPixelHeight'_ :: ((HG3DClassPtr) -> ((Ptr CFloat) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isMousePassThroughEnabled"
  isMousePassThroughEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isAutoWindow"
  isAutoWindow'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isWritingXMLAllowed"
  isWritingXMLAllowed'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isDragDropTarget"
  isDragDropTarget'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isUsingAutoRenderingSurface"
  isUsingAutoRenderingSurface'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getRootWindow"
  getRootWindow'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getRootWindow2"
  getRootWindow2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isNonClientWindow"
  isNonClientWindow'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_rename"
  rename'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_initialiseComponents"
  initialiseComponents'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setDestroyedByParent"
  setDestroyedByParent'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setAlwaysOnTop"
  setAlwaysOnTop'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setEnabled"
  setEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_enable"
  enable'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_disable"
  disable'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setVisible"
  setVisible'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_show"
  show'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_hide"
  hide'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_activate"
  activate'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_deactivate"
  deactivate'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setClippedByParent"
  setClippedByParent'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setID"
  setID'_ :: ((HG3DClassPtr) -> (CUInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setText"
  setText'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_appendText"
  appendText'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setFont"
  setFont'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setFont2"
  setFont2'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_addChildWindow"
  addChildWindow'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_addChildWindow2"
  addChildWindow2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_removeChildWindow"
  removeChildWindow'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_removeChildWindow2"
  removeChildWindow2'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_removeChildWindow3"
  removeChildWindow3'_ :: ((HG3DClassPtr) -> (CUInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_moveToFront"
  moveToFront'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_moveToBack"
  moveToBack'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_captureInput"
  captureInput'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_releaseInput"
  releaseInput'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setRestoreCapture"
  setRestoreCapture'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setAlpha"
  setAlpha'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setInheritsAlpha"
  setInheritsAlpha'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_invalidate"
  invalidate'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_invalidate2"
  invalidate2'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setMouseCursor3"
  setMouseCursor3'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setZOrderingEnabled"
  setZOrderingEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setWantsMultiClickEvents"
  setWantsMultiClickEvents'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setMouseAutoRepeatEnabled"
  setMouseAutoRepeatEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setAutoRepeatDelay"
  setAutoRepeatDelay'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setAutoRepeatRate"
  setAutoRepeatRate'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setDistributesCapturedInputs"
  setDistributesCapturedInputs'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_notifyDragDropItemEnters"
  notifyDragDropItemEnters'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_notifyDragDropItemLeaves"
  notifyDragDropItemLeaves'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_notifyDragDropItemDropped"
  notifyDragDropItemDropped'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_destroy"
  destroy'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setTooltip"
  setTooltip'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setTooltipType"
  setTooltipType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setTooltipText"
  setTooltipText'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setInheritsTooltipText"
  setInheritsTooltipText'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setRiseOnClickEnabled"
  setRiseOnClickEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setVerticalAlignment"
  setVerticalAlignment'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setHorizontalAlignment"
  setHorizontalAlignment'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setLookNFeel"
  setLookNFeel'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setModalState"
  setModalState'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_performChildWindowLayout"
  performChildWindowLayout'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setUserString"
  setUserString'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_render"
  render'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_update"
  update'_ :: ((HG3DClassPtr) -> (CFloat -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_beginInitialisation"
  beginInitialisation'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_endInitialisation"
  endInitialisation'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setMousePassThroughEnabled"
  setMousePassThroughEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setWindowRenderer"
  setWindowRenderer'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getWindowRendererName"
  getWindowRendererName'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setWritingXMLAllowed"
  setWritingXMLAllowed'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_notifyScreenAreaChanged"
  notifyScreenAreaChanged'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setFalagardType"
  setFalagardType'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> ((Ptr CChar) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setDragDropTarget"
  setDragDropTarget'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_invalidateRenderingSurface"
  invalidateRenderingSurface'_ :: ((HG3DClassPtr) -> (IO ()))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setUsingAutoRenderingSurface"
  setUsingAutoRenderingSurface'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setNonClientWindow"
  setNonClientWindow'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isTextParsingEnabled"
  isTextParsingEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setTextParsingEnabled"
  setTextParsingEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_banPropertyFromXML"
  banPropertyFromXML'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_unbanPropertyFromXML"
  unbanPropertyFromXML'_ :: ((HG3DClassPtr) -> ((Ptr CChar) -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setUpdateMode"
  setUpdateMode'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getUpdateMode"
  getUpdateMode'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_setMouseInputPropagationEnabled"
  setMouseInputPropagationEnabled'_ :: ((HG3DClassPtr) -> (CInt -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isMouseInputPropagationEnabled"
  isMouseInputPropagationEnabled'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

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

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_clonePropertiesTo"
  clonePropertiesTo'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_cloneChildWidgetsTo"
  cloneChildWidgetsTo'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getZIndex"
  getZIndex'_ :: ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ())))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isInFront"
  isInFront'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_isBehind"
  isBehind'_ :: ((HG3DClassPtr) -> ((HG3DClassPtr) -> ((Ptr CInt) -> (IO ()))))

foreign import ccall safe "HGamer3D\\Bindings\\CEGUI\\ClassWindow.chs.h cegui_wnd_getCaptureWindow"
  getCaptureWindow'_ :: ((HG3DClassPtr) -> (IO ()))