;; From ClutterActor

(define-signal destroy
  (of-object "ClutterActor")
  (return-type "void")
  (when "unknown")
)

(define-signal show
  (of-object "ClutterActor")
  (return-type "void")
  (when "first")
)

(define-signal hide
  (of-object "ClutterActor")
  (return-type "void")
  (when "first")
)

(define-signal parent-set
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-signal queue-redraw
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-signal queue-relayout
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

(define-signal event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal button-press-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterButtonEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal button-release-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterButtonEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal scroll-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterScrollEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal key-press-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterKeyEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal key-release-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterKeyEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal motion-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterMotionEvent*" "p0")
  )
)

(define-signal key-focus-in
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

(define-signal key-focus-out
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

;; Hand-edited to use more specific event type
(define-signal enter-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterCrossingEvent*" "p0")
  )
)

;; Hand-edited to use more specific event type
(define-signal leave-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterCrossingEvent*" "p0")
  )
)

(define-signal captured-event
  (of-object "ClutterActor")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterEvent*" "p0")
  )
)

(define-signal paint
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

(define-signal realize
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

(define-signal unrealize
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
)

(define-signal pick
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterColor*" "p0")
  )
)

(define-signal allocation-changed
  (of-object "ClutterActor")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterActorBox*" "p0")
    '("ClutterAllocationFlags" "p1")
  )
)

(define-property name
  (of-object "ClutterActor")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterActor")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterActor")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterActor")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterActor")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterActor")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterActor")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterActor")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterActor")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterActor")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterActor")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterActor")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterActor")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterActor")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterActor")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterActor")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterActor")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterActor")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterActor")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)


;; From ClutterAlpha

(define-property timeline
  (of-object "ClutterAlpha")
  (prop-type "GParamObject")
  (docs "Timeline used by the alpha")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property alpha
  (of-object "ClutterAlpha")
  (prop-type "GParamDouble")
  (docs "Alpha value")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property mode
  (of-object "ClutterAlpha")
  (prop-type "GParamULong")
  (docs "Progress mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterAnimation

(define-signal completed
  (of-object "ClutterAnimation")
  (return-type "void")
  (when "last")
)

(define-signal started
  (of-object "ClutterAnimation")
  (return-type "void")
  (when "last")
)

(define-property object
  (of-object "ClutterAnimation")
  (prop-type "GParamObject")
  (docs "Object to which the animation applies")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mode
  (of-object "ClutterAnimation")
  (prop-type "GParamULong")
  (docs "The mode of the animation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property duration
  (of-object "ClutterAnimation")
  (prop-type "GParamUInt")
  (docs "Duration of the animation, in milliseconds")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property loop
  (of-object "ClutterAnimation")
  (prop-type "GParamBoolean")
  (docs "Whether the animation should loop")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property timeline
  (of-object "ClutterAnimation")
  (prop-type "GParamObject")
  (docs "The timeline used by the animation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property alpha
  (of-object "ClutterAnimation")
  (prop-type "GParamObject")
  (docs "The alpha used by the animation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBackend

(define-signal resolution-changed
  (of-object "ClutterBackend")
  (return-type "void")
  (when "first")
)

(define-signal font-changed
  (of-object "ClutterBackend")
  (return-type "void")
  (when "first")
)

;; From ClutterBehaviourDepth

(define-property alpha
  (of-object "ClutterBehaviourDepth")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property depth-start
  (of-object "ClutterBehaviourDepth")
  (prop-type "GParamInt")
  (docs "Initial depth to apply")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property depth-end
  (of-object "ClutterBehaviourDepth")
  (prop-type "GParamInt")
  (docs "Final depth to apply")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviourEllipse

(define-property alpha
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property center
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamBoxed")
  (docs "Center of ellipse")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamInt")
  (docs "Width of the ellipse")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamInt")
  (docs "Height of ellipse")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-start
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamDouble")
  (docs "Initial angle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-end
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamDouble")
  (docs "Final angle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-tilt-x
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamDouble")
  (docs "Tilt of the ellipse around x axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-tilt-y
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamDouble")
  (docs "Tilt of the ellipse around y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-tilt-z
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamDouble")
  (docs "Tilt of the ellipse around z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property direction
  (of-object "ClutterBehaviourEllipse")
  (prop-type "GParamEnum")
  (docs "Direction of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviour

(define-signal applied
  (of-object "ClutterBehaviour")
  (return-type "void")
  (when "first")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-signal removed
  (of-object "ClutterBehaviour")
  (return-type "void")
  (when "first")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-property alpha
  (of-object "ClutterBehaviour")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviourOpacity

(define-property alpha
  (of-object "ClutterBehaviourOpacity")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity-start
  (of-object "ClutterBehaviourOpacity")
  (prop-type "GParamUInt")
  (docs "Initial opacity level")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity-end
  (of-object "ClutterBehaviourOpacity")
  (prop-type "GParamUInt")
  (docs "Final opacity level")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviourPath

(define-signal knot-reached
  (of-object "ClutterBehaviourPath")
  (return-type "void")
  (when "last")
  (parameters
    '("guint" "p0")
  )
)

(define-property alpha
  (of-object "ClutterBehaviourPath")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property path
  (of-object "ClutterBehaviourPath")
  (prop-type "GParamObject")
  (docs "The ClutterPath object representing the path to animate along")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviourRotate

(define-property alpha
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-start
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamDouble")
  (docs "Initial angle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property angle-end
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamDouble")
  (docs "Final angle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property axis
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamEnum")
  (docs "Axis of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property direction
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamEnum")
  (docs "Direction of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property center-x
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamInt")
  (docs "X center of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property center-y
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamInt")
  (docs "Y center of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property center-z
  (of-object "ClutterBehaviourRotate")
  (prop-type "GParamInt")
  (docs "Z center of rotation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterBehaviourScale

(define-property alpha
  (of-object "ClutterBehaviourScale")
  (prop-type "GParamObject")
  (docs "Alpha Object to drive the behaviour")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x-scale-start
  (of-object "ClutterBehaviourScale")
  (prop-type "GParamDouble")
  (docs "Initial scale on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y-scale-start
  (of-object "ClutterBehaviourScale")
  (prop-type "GParamDouble")
  (docs "Initial scale on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x-scale-end
  (of-object "ClutterBehaviourScale")
  (prop-type "GParamDouble")
  (docs "Final scale on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y-scale-end
  (of-object "ClutterBehaviourScale")
  (prop-type "GParamDouble")
  (docs "Final scale on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterCairoTexture

(define-property name
  (of-object "ClutterCairoTexture")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterCairoTexture")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)


(define-property reactive
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterCairoTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property disable-slicing
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Force the underlying texture to be singlularand not made of of smaller space saving inidivual textures.")
  (readable #t)
  (writable #t)
  (construct-only #t)
)

(define-property tile-waste
  (of-object "ClutterCairoTexture")
  (prop-type "GParamInt")
  (docs "Maximum waste area of a sliced texture")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property pixel-format
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "CoglPixelFormat to use.")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property sync-size
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Auto sync size of actor to underlying pixbuf dimensions")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property repeat-y
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Repeat underlying pixbuf rather than scale in y direction.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property repeat-x
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Repeat underlying pixbuf rather than scale in x direction.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property filter-quality
  (of-object "ClutterCairoTexture")
  (prop-type "GParamEnum")
  (docs "Rendering quality used when drawing the texture.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cogl-texture
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The underlying COGL texture handle used to draw this actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cogl-material
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoxed")
  (docs "The underlying COGL material handle used to draw this actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property filename
  (of-object "ClutterCairoTexture")
  (prop-type "GParamString")
  (docs "The full path of the file containing the texture")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

(define-property keep-aspect-ratio
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Keep the aspect ratio of the texture when requesting the preferred width or height")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property load-async
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Load files inside a thread to avoid blocking when loading images.")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

(define-property load-data-async
  (of-object "ClutterCairoTexture")
  (prop-type "GParamBoolean")
  (docs "Decode image data files inside a thread to reduce blocking when loading images.")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

(define-property surface-width
  (of-object "ClutterCairoTexture")
  (prop-type "GParamUInt")
  (docs "Surface Width")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property surface-height
  (of-object "ClutterCairoTexture")
  (prop-type "GParamUInt")
  (docs "Surface Height")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterChildMeta

(define-property container
  (of-object "ClutterChildMeta")
  (prop-type "GParamObject")
  (docs "The container that created this data")
  (readable #t)
  (writable #t)
  (construct-only #t)
)

(define-property actor
  (of-object "ClutterChildMeta")
  (prop-type "GParamObject")
  (docs "The actor wrapped by this data")
  (readable #t)
  (writable #t)
  (construct-only #t)
)

;; From ClutterClone

(define-property name
  (of-object "ClutterClone")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterClone")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterClone")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterClone")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterClone")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterClone")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterClone")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterClone")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterClone")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterClone")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterClone")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterClone")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterClone")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterClone")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterClone")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterClone")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterClone")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterClone")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterClone")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)


(define-property source
  (of-object "ClutterClone")
  (prop-type "GParamObject")
  (docs "Specifies the actor to be cloned")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterColor

;; From ClutterContainer

(define-signal actor-added
  (of-object "ClutterContainer")
  (return-type "void")
  (when "first")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-signal actor-removed
  (of-object "ClutterContainer")
  (return-type "void")
  (when "first")
  (parameters
    '("ClutterActor*" "p0")
  )
)

(define-signal child-notify
  (of-object "ClutterContainer")
  (return-type "void")
  (when "first")
  (parameters
    '("ClutterActor*" "p0")
    '("GParam" "p1")
  )
)

;; From ClutterEvent

;; From ClutterGroup

(define-property name
  (of-object "ClutterGroup")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterGroup")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterGroup")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterGroup")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterGroup")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterGroup")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterGroup")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterGroup")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterGroup")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterGroup")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterGroup")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterGroup")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterGroup")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterGroup")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterGroup")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterGroup")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterGroup")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)


(define-property text-direction
  (of-object "ClutterGroup")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterGroup")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

;; From ClutterInterval

(define-property value-type
  (of-object "ClutterInterval")
  (prop-type "GParamGType")
  (docs "The type of the values in the interval")
  (readable #t)
  (writable #t)
  (construct-only #t)
)

;; From ClutterMedia

(define-signal eos
  (of-object "ClutterMedia")
  (return-type "void")
  (when "last")
)

(define-signal error
  (of-object "ClutterMedia")
  (return-type "void")
  (when "last")
  (parameters
    '("gpointer" "p0")
  )
)


(define-property duration
  (of-object "ClutterMedia")
  (prop-type "GParamDouble")
  (docs "The duration of the stream, in seconds")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property can-seek
  (of-object "ClutterMedia")
  (prop-type "GParamBoolean")
  (docs "Whether the current stream is seekable")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property buffer-fill
  (of-object "ClutterMedia")
  (prop-type "GParamDouble")
  (docs "The fill level of the buffer")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property playing
  (of-object "ClutterMedia")
  (prop-type "GParamBoolean")
  (docs "Wheter the actor is playing")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property subtitle-font-name
  (of-object "ClutterMedia")
  (prop-type "GParamString")
  (docs "The font used to display subtitles")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property audio-volume
  (of-object "ClutterMedia")
  (prop-type "GParamDouble")
  (docs "The volume of the audio")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property progress
  (of-object "ClutterMedia")
  (prop-type "GParamDouble")
  (docs "Current progress of the playback")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property subtitle-uri
  (of-object "ClutterMedia")
  (prop-type "GParamString")
  (docs "URI of a subtitle file")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property uri
  (of-object "ClutterMedia")
  (prop-type "GParamString")
  (docs "URI of a media file")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterPath

(define-property description
  (of-object "ClutterPath")
  (prop-type "GParamString")
  (docs "SVG-style description of the path")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property length
  (of-object "ClutterPath")
  (prop-type "GParamUInt")
  (docs "An approximation of the total length of the path.")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

;; From ClutterRectangle

(define-property name
  (of-object "ClutterRectangle")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterRectangle")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterRectangle")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterRectangle")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterRectangle")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterRectangle")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterRectangle")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterRectangle")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterRectangle")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterRectangle")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterRectangle")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterRectangle")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterRectangle")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterRectangle")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterRectangle")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterRectangle")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterRectangle")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterRectangle")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property color
  (of-object "ClutterRectangle")
  (prop-type "ClutterParamSpecColor")
  (docs "The color of the rectangle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property border-color
  (of-object "ClutterRectangle")
  (prop-type "ClutterParamSpecColor")
  (docs "The color of the border of the rectangle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property border-width
  (of-object "ClutterRectangle")
  (prop-type "GParamUInt")
  (docs "The width of the border of the rectangle")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-border
  (of-object "ClutterRectangle")
  (prop-type "GParamBoolean")
  (docs "Whether the rectangle should have a border")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterScore

(define-signal timeline-started
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterTimeline*" "p0")
  )
)

(define-signal timeline-completed
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterTimeline*" "p0")
  )
)

(define-signal completed
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-signal started
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-signal paused
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-property loop
  (of-object "ClutterScore")
  (prop-type "GParamBoolean")
  (docs "Whether the score should restart once finished")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterScript

(define-property filename-set
  (of-object "ClutterScript")
  (prop-type "GParamBoolean")
  (docs "Whether the :filename property is set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property filename
  (of-object "ClutterScript")
  (prop-type "GParamString")
  (docs "The path of the currently parsed file")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

;; From ClutterStage


(define-signal activate
  (of-object "ClutterStage")
  (return-type "void")
  (when "last")
)

(define-signal fullscreen
  (of-object "ClutterStage")
  (return-type "void")
  (when "first")
)

(define-signal unfullscreen
  (of-object "ClutterStage")
  (return-type "void")
  (when "last")
)

(define-signal deactivate
  (of-object "ClutterStage")
  (return-type "void")
  (when "last")
)

(define-signal delete-event
  (of-object "ClutterStage")
  (return-type "gboolean")
  (when "last")
  (parameters
    '("ClutterEvent*" "p0")
  )
)

(define-property name
  (of-object "ClutterStage")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterStage")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterStage")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterStage")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterStage")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterStage")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterStage")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterStage")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterStage")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterStage")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterStage")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterStage")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterStage")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property color
  (of-object "ClutterStage")
  (prop-type "ClutterParamSpecColor")
  (docs "The color of the stage")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fullscreen-set
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the main stage is fullscreen")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property offscreen
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the main stage should be rendered offscreen")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cursor-visible
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the mouse pointer is visible on the main stage")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property perspective
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "Perspective projection parameters")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property title
  (of-object "ClutterStage")
  (prop-type "GParamString")
  (docs "Stage Title")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property user-resizable
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether the stage is able to be resized via user interaction")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property use-fog
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to enable depth cueing")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fog
  (of-object "ClutterStage")
  (prop-type "GParamBoxed")
  (docs "Settings for the depth cueing")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property use-alpha
  (of-object "ClutterStage")
  (prop-type "GParamBoolean")
  (docs "Whether to honour the alpha component of the stage color")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property key-focus
  (of-object "ClutterStage")
  (prop-type "GParamObject")
  (docs "The currently key focused actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterText

(define-signal text-changed
  (of-object "ClutterText")
  (return-type "void")
  (when "last")
)

(define-signal insert-text
  (of-object "ClutterText")
  (return-type "void")
  (when "last")
  (parameters
    '("const-gchar*" "p0")
    '("gint" "p1")
    '("gpointer" "p2")
  )
)

(define-signal delete-text
  (of-object "ClutterText")
  (return-type "void")
  (when "last")
  (parameters
    '("gint" "p0")
    '("gint" "p1")
  )
)

;; Hand-edited to add constness
(define-signal cursor-event
  (of-object "ClutterText")
  (return-type "void")
  (when "last")
  (parameters
    '("const-ClutterGeometry*" "p0")
  )
)

(define-signal activate
  (of-object "ClutterText")
  (return-type "void")
  (when "last")
)

(define-property name
  (of-object "ClutterText")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterText")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterText")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterText")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterText")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterText")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterText")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text-direction
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property font-name
  (of-object "ClutterText")
  (prop-type "GParamString")
  (docs "The font to be used by the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property font-description
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "The font description to be used")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property text
  (of-object "ClutterText")
  (prop-type "GParamString")
  (docs "The text to render")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property color
  (of-object "ClutterText")
  (prop-type "ClutterParamSpecColor")
  (docs "Color of the font used by the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property use-markup
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether or not the text includes Pango markup")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property attributes
  (of-object "ClutterText")
  (prop-type "GParamBoxed")
  (docs "A list of style attributes to apply to the contents of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property line-alignment
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "The preferred alignment for the string, for multi-line text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property line-wrap
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "If set, wrap the lines if the text becomes too wide")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property line-wrap-mode
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "Control how line-wrapping is done")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property justify
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the text should be justified")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property ellipsize
  (of-object "ClutterText")
  (prop-type "GParamEnum")
  (docs "The preferred place to ellipsize the string")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property position
  (of-object "ClutterText")
  (prop-type "GParamInt")
  (docs "The cursor position")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property selection-bound
  (of-object "ClutterText")
  (prop-type "GParamInt")
  (docs "The cursor position of the other end of the selection")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property selection-color
  (of-object "ClutterText")
  (prop-type "ClutterParamSpecColor")
  (docs "Selection Color")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property selection-color-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the selection color has been set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property cursor-visible
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the input cursor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cursor-color
  (of-object "ClutterText")
  (prop-type "ClutterParamSpecColor")
  (docs "Cursor Color")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cursor-color-set
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the cursor color has been set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property cursor-size
  (of-object "ClutterText")
  (prop-type "GParamInt")
  (docs "The width of the cursor, in pixels")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property editable
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the text is editable")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property selectable
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the text is selectable")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property activatable
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether pressing return causes the activate signal to be emitted")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property password-char
  (of-object "ClutterText")
  (prop-type "GParamUnichar")
  (docs "If non-zero, use this character to display the actor's contents")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property max-length
  (of-object "ClutterText")
  (prop-type "GParamFloat")
  (docs "Maximum length of the text inside the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property single-line-mode
  (of-object "ClutterText")
  (prop-type "GParamBoolean")
  (docs "Whether the text should be a single line")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterTexture

(define-signal size-change
  (of-object "ClutterTexture")
  (return-type "void")
  (when "last")
  (parameters
    '("gint" "p0")
    '("gint" "p1")
  )
)

(define-signal pixbuf-change
  (of-object "ClutterTexture")
  (return-type "void")
  (when "last")
)

(define-signal load-finished
  (of-object "ClutterTexture")
  (return-type "void")
  (when "last")
  (parameters
    '("gpointer" "p0")
  )
)

(define-property name
  (of-object "ClutterTexture")
  (prop-type "GParamString")
  (docs "Name of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property x
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "X coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property y
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property width
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Width of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property height
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Height of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-x
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced X position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-y
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced Y position of the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fixed-position-set
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use fixed positioning for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced minimum width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-width-set
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced minimum height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property min-height-set
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the min-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced natural width request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-width-set
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-width property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Forced natural height request for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property natural-height-set
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether to use the natural-height property")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property request-mode
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "The actor's request mode")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property allocation
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The actor's allocation")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property depth
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Position on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property clip
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The clip region for the actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-clip
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has a clip set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property clip-to-allocation
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Sets the clip region to track the actor's allocation")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property opacity
  (of-object "ClutterTexture")
  (prop-type "GParamUInt")
  (docs "Opacity of an actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property visible
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is visible")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property mapped
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor will be painted")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property realized
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor has been realized")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property reactive
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is reactive to events")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-x
  (of-object "ClutterTexture")
  (prop-type "GParamDouble")
  (docs "Scale factor on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-y
  (of-object "ClutterTexture")
  (prop-type "GParamDouble")
  (docs "Scale factor on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-x
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Horizontal scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-center-y
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Vertical scale center")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property scale-gravity
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "The center of scaling")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-x
  (of-object "ClutterTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-y
  (of-object "ClutterTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-angle-z
  (of-object "ClutterTexture")
  (prop-type "GParamDouble")
  (docs "The rotation angle on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-x
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the X axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-y
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Y axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The rotation center on the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property rotation-center-z-gravity
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "Center point for rotation around the Z axis")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-x
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "X coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-y
  (of-object "ClutterTexture")
  (prop-type "GParamFloat")
  (docs "Y coordinate of the anchor point")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property anchor-gravity
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "The anchor point as a ClutterGravity")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property show-on-set-parent
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor is shown when parented")
  (readable #t)
  (writable #t)
  (construct-only #f)
)


(define-property text-direction
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "Direction of the text")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property has-pointer
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Whether the actor contains the pointer of an input device")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property disable-slicing
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Force the underlying texture to be singlularand not made of of smaller space saving inidivual textures.")
  (readable #t)
  (writable #t)
  (construct-only #t)
)

(define-property tile-waste
  (of-object "ClutterTexture")
  (prop-type "GParamInt")
  (docs "Maximum waste area of a sliced texture")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property pixel-format
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "CoglPixelFormat to use.")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property sync-size
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Auto sync size of actor to underlying pixbuf dimensions")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property repeat-y
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Repeat underlying pixbuf rather than scale in y direction.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property repeat-x
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Repeat underlying pixbuf rather than scale in x direction.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property filter-quality
  (of-object "ClutterTexture")
  (prop-type "GParamEnum")
  (docs "Rendering quality used when drawing the texture.")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cogl-texture
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The underlying COGL texture handle used to draw this actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property cogl-material
  (of-object "ClutterTexture")
  (prop-type "GParamBoxed")
  (docs "The underlying COGL material handle used to draw this actor")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property filename
  (of-object "ClutterTexture")
  (prop-type "GParamString")
  (docs "The full path of the file containing the texture")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

(define-property keep-aspect-ratio
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Keep the aspect ratio of the texture when requesting the preferred width or height")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property load-async
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Load files inside a thread to avoid blocking when loading images.")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

(define-property load-data-async
  (of-object "ClutterTexture")
  (prop-type "GParamBoolean")
  (docs "Decode image data files inside a thread to reduce blocking when loading images.")
  (readable #f)
  (writable #t)
  (construct-only #f)
)

;; From ClutterTimeline

(define-signal completed
  (of-object "ClutterTimeline")
  (return-type "void")
  (when "last")
)

(define-signal started
  (of-object "ClutterTimeline")
  (return-type "void")
  (when "last")
)

(define-signal paused
  (of-object "ClutterTimeline")
  (return-type "void")
  (when "last")
)

(define-signal new-frame
  (of-object "ClutterTimeline")
  (return-type "void")
  (when "last")
  (parameters
    '("gint" "p0")
  )
)

(define-signal marker-reached
  (of-object "ClutterTimeline")
  (return-type "void")
  (when "last")
  (parameters
    '("const-gchar*" "p0")
    '("gint" "p1")
  )
)

(define-property loop
  (of-object "ClutterTimeline")
  (prop-type "GParamBoolean")
  (docs "Should the timeline automatically restart")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property delay
  (of-object "ClutterTimeline")
  (prop-type "GParamUInt")
  (docs "Delay before start")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property duration
  (of-object "ClutterTimeline")
  (prop-type "GParamUInt")
  (docs "Duration of the timeline in milliseconds")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property direction
  (of-object "ClutterTimeline")
  (prop-type "GParamEnum")
  (docs "Direction of the timeline")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterScore

(define-signal timeline-started
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterTimeline*" "p0")
  )
)

(define-signal timeline-completed
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
  (parameters
    '("ClutterTimeline*" "p0")
  )
)

(define-signal completed
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-signal started
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-signal paused
  (of-object "ClutterScore")
  (return-type "void")
  (when "last")
)

(define-property loop
  (of-object "ClutterScore")
  (prop-type "GParamBoolean")
  (docs "Whether the score should restart once finished")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterShader

(define-property vertex-source
  (of-object "ClutterShader")
  (prop-type "GParamString")
  (docs "Source of vertex shader")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property fragment-source
  (of-object "ClutterShader")
  (prop-type "GParamString")
  (docs "Source of fragment shader")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

(define-property compiled
  (of-object "ClutterShader")
  (prop-type "GParamBoolean")
  (docs "Whether the shader is compiled and linked")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property enabled
  (of-object "ClutterShader")
  (prop-type "GParamBoolean")
  (docs "Whether the shader is enabled")
  (readable #t)
  (writable #t)
  (construct-only #f)
)

;; From ClutterScript

(define-property filename-set
  (of-object "ClutterScript")
  (prop-type "GParamBoolean")
  (docs "Whether the :filename property is set")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

(define-property filename
  (of-object "ClutterScript")
  (prop-type "GParamString")
  (docs "The path of the currently parsed file")
  (readable #t)
  (writable #f)
  (construct-only #f)
)

