import eina_types;

interface Efl.Input.Interface ()
{
   [[An object implementing this interface can send pointer events.

     Windows and canvas objects may send input events.

     A "pointer" refers to the main pointing device, which could be a mouse,
     trackpad, finger, pen, etc... In other words, the finger id in any
     pointer event will always be 0.

     A "finger" refers to a single point of input, usually in an absolute
     coordinates input device, and that can support more than one input
     position at at time (think multi-touch screens). The first finger (id 0)
     is sent along with a pointer event, so be careful to not handle those
     events twice. Note that if the input device can support "hovering", it
     is entirely possible to receive move events without down coming first.

     A "key" is a key press from a keyboard or equivalent type of input device.
     Long, repeated, key presses will always happen like this:
     down...up,down...up,down...up (not down...up or down...down...down...up).

     @since 1.19
   ]]
   eo_prefix: efl_input;
   event_prefix: efl;
   methods {
      @property pointer_position {
         get {
            [[This function returns the current known pointer coordinates

              This function returns the current position of the main input
              pointer (mouse, pen, etc...).
            ]]
         }
         values {
            pos: Eina.Position2D; [[The pointer position in pixels.]]
         }
      }
      @property pointer_inside {
         get {
            [[Returns whether the mouse pointer is logically inside the
              canvas.

              When this function is called it will return a value of either
              $false or $true, depending on whether a pointer,in or pointer,out
              event has been called previously.

              A return value of $true indicates the mouse is logically
              inside the canvas, and $false implies it is logically
              outside the canvas.

              A canvas begins with the mouse being assumed outside ($false).
            ]]
            return: bool; [[$true if the mouse pointer is inside the canvas, $false otherwise]]
         }
      }
      pointer_iterate @const {
         [[Returns an iterator over the current known pointer positions.

           This is used to iterate over the current known multi-touch positions,
           including the first finger. Each pointer position is represented by
           an object of type @Efl.Input.Pointer.

           Each finger in a multi touch environment can then be identified
           by the @Efl.Input.Pointer.tool property. The order of the pointers
           in this iterator is not defined.

           Note: If the input surface supports hovering input, some pointers
           may not be in a "down" state. To retrieve the list of such pointers,
           set the $hover value to $true. Remember though that most devices
           currently don't support this.
         ]]
         params {
            hover: bool @optional; [[$false by default, $true means to include
                                     fingers that are currently hovering.]]
         }
         return: iterator<const(Efl.Input.Pointer)>; [[Iterator to pointer positions]]
      }
      @property seat_event_filter {
          set {
             [[Add or remove a given seat to the filter list. If the filter list is empty this object
               will report mouse, keyboard and focus events from any seat, otherwise those events will
               only be reported if the event comes from a seat that is in the list.]]
          }
          get {
             [[Check if input events from a given seat is enabled.]]
          }
          keys {
             seat: Efl.Input.Device; [[The seat to act on.]]
          }
          values {
             enable: bool; [[$true to enable events for a seat or $false otherwise.]]
          }
      }
   }
   events {
      pointer,move: Efl.Input.Pointer;   [[Main pointer move (current and previous positions are known).]]
      pointer,down: Efl.Input.Pointer;   [[Main pointer button pressed (button id is known).]]
      pointer,up: Efl.Input.Pointer;     [[Main pointer button released (button id is known).]]
      pointer,cancel: Efl.Input.Pointer; [[Main pointer button press was cancelled (button id is known).
                                           This can happen in rare cases when the window manager passes
                                           the focus to a more urgent window, for instance. You probably
                                           don't need to listen to this event, as it will be accompanied
                                           by an up event.]]
      pointer,in: Efl.Input.Pointer;     [[Pointer entered a window or a widget.]]
      pointer,out: Efl.Input.Pointer;    [[Pointer left a window or a widget.]]
      pointer,wheel: Efl.Input.Pointer;  [[Mouse wheel event.]]
      pointer,axis: Efl.Input.Pointer;   [[Pen or other axis event update.]]
      finger,move: Efl.Input.Pointer;    [[Finger moved (current and previous positions are known).]]
      finger,down: Efl.Input.Pointer;    [[Finger pressed (finger id is known).]]
      finger,up: Efl.Input.Pointer;      [[Finger released (finger id is known).]]
      key,down: Efl.Input.Key;           [[Keyboard key press.]]
      key,up: Efl.Input.Key;             [[Keyboard key release.]]
      hold: Efl.Input.Hold;              [[All input events are on hold or resumed.]]
      focus,in: Efl.Input.Focus;         [[A focus in event.]]
      focus,out: Efl.Input.Focus;        [[A focus out event.]]
   }
}