const Efl.Gfx.Stack_Layer_Min: short = -32768; [[bottom-most layer number @since 1.23]]
const Efl.Gfx.Stack_Layer_Max: short = 32767;  [[top-most layer number @since 1.23]]

interface Efl.Gfx.Stack
{
   [[Efl graphics stack interface

     @since 1.22
   ]]
   event_c_prefix: efl_gfx_entity;
   methods {
      @property layer {
         [[The layer of its canvas that the given object will be part of.

           If you don't use this property, you'll be dealing with a unique
           layer of objects (the default one). Additional layers are handy when
           you don't want a set of objects to interfere with another set with
           regard to stacking. Two layers are completely disjoint in that
           matter.

           This is a low-level function, which you'd be using when something
           should be always on top, for example.

           Warning: Don't change the layer of
           smart objects' children. Smart objects have a layer of their own,
           which should contain all their child objects.
         ]]
         set {
         }
         get {
         }
         values {
            l: short; [[The number of the layer to place the object on.
                        Must be between @Efl.Gfx.Stack_Layer_Min and @Efl.Gfx.Stack_Layer_Max.]]
         }
      }
      @property below {
         [[The Evas object stacked right below this object.

           This function will traverse layers in its search, if there are
           objects on layers below the one $obj is placed at.

           See also @.layer.]]
         get {
         }
         values {
            below: Efl.Gfx.Stack; [[The @Efl.Gfx.Stack object directly below $obj, if any,
                                                or $null, if none.]]
         }
      }
      @property above {
         [[Get the Evas object stacked right above this object.

           This function will traverse layers in its search, if there are
           objects on layers above the one $obj is placed at.

           See also @.layer and @.below]]
         get {
         }
         values {
            above: Efl.Gfx.Stack; [[The @Efl.Gfx.Stack object directly below $obj, if any,
                                                or $null, if none.]]
         }
      }
      stack_below {
         [[Stack $obj immediately $below

           Objects, in a given canvas, are stacked in the order they're added.
           This means that, if they overlap, the highest ones will
           cover the lowest ones, in that order. This function is a way to
           change the stacking order for the objects.

           Its intended to be used with objects belonging to
           the same layer in a given canvas, otherwise it will fail (and
           accomplish nothing).

           If you have smart objects on your canvas and $obj is a member of
           one of them, then $below must also be a member of the same
           smart object.

           Similarly, if $obj is not a member of a smart object, $below
           must not be either.

           See also @.layer.get(), @.layer.set() and @.stack_below()]]

         params {
            @in below: Efl.Gfx.Stack; [[The object below which to stack]]
         }
      }
      raise_to_top {
         [[Raise $obj to the top of its layer.

           $obj will, then, be the highest one in the layer it belongs
           to. Object on other layers won't get touched.

           See also @.stack_above(), @.stack_below() and @.lower_to_bottom()]]

      }
      stack_above {
         [[Stack $obj immediately $above

           Objects, in a given canvas, are stacked in the order they're added.
           This means that, if they overlap, the highest ones will
           cover the lowest ones, in that order. This function is a way to
           change the stacking order for the objects.

           Its intended to be used with objects belonging to
           the same layer in a given canvas, otherwise it will fail (and
           accomplish nothing).

           If you have smart objects on your canvas and $obj is a member of
           one of them, then $above must also be a member of the same
           smart object.

           Similarly, if $obj is not a member of a smart object, $above
           must not be either.

           See also @.layer.get(), @.layer.set() and @.stack_below()]]

         params {
            @in above: Efl.Gfx.Stack; [[The object above which to stack]]
         }
      }
      lower_to_bottom {
         [[Lower $obj to the bottom of its layer.

           $obj will, then, be the lowest one in the layer it belongs
           to. Objects on other layers won't get touched.

           See also @.stack_above(), @.stack_below() and @.raise_to_top() ]]

      }
   }
   events {
      stacking,changed: void; [[Object stacking was changed.]]
   }
}