Source file pointer_constraints_unstable_v1_client.ml

(* This file was generated automatically by wayland-scanner-ocaml *)

[@@@ocaml.warning "-27"]
open struct
  module Imports = struct
    include Pointer_constraints_unstable_v1_proto
    include Wayland.Wayland_proto
  end
  
  module Proxy = Wayland.Proxy
  module Msg = Wayland.Msg
  module Fixed = Wayland.Fixed
  module Iface_reg = Wayland.Iface_reg
  module S = Wayland.S
end


(** Constrain the movement of a pointer.
    
    The global interface exposing pointer constraining functionality. It
    exposes two requests: lock_pointer for locking the pointer to its
    position, and confine_pointer for locking the pointer to a region.
    
    The lock_pointer and confine_pointer requests create the objects
    wp_locked_pointer and wp_confined_pointer respectively, and the client can
    use these objects to interact with the lock.
    
    For any surface, only one lock or confinement may be active across all
    wl_pointer objects of the same seat. If a lock or confinement is requested
    when another lock or confinement is active or requested on the same surface
    and with any of the wl_pointer objects of the same seat, an
    'already_constrained' error will be raised. *)
module Zwp_pointer_constraints_v1 = struct
  type 'v t = ([`Zwp_pointer_constraints_v1], 'v, [`Client]) Proxy.t
  module Error = Pointer_constraints_unstable_v1_proto.Zwp_pointer_constraints_v1.Error
  
  module Lifetime = Pointer_constraints_unstable_v1_proto.Zwp_pointer_constraints_v1.Lifetime
  
  (** {2 Version 1} *)
  
  (** Confine pointer to a region.
      
      The confine_pointer request lets the client request to confine the
      pointer cursor to a given region. This request may not take effect
      immediately; in the future, when the compositor deems implementation-
      specific constraints are satisfied, the pointer confinement will be
      activated and the compositor sends a confined event.
      
      The intersection of the region passed with this request and the input
      region of the surface is used to determine where the pointer must be
      in order for the confinement to activate. It is up to the compositor
      whether to warp the pointer or require some kind of user interaction for
      the confinement to activate. If the region is null the surface input
      region is used.
      
      The request will create a new object wp_confined_pointer which is used
      to interact with the confinement as well as receive updates about its
      state. See the the description of wp_confined_pointer for further
      information. *)
  let confine_pointer (_t:([< `V1] as 'v) t) (id:([`Zwp_confined_pointer_v1], 'v, [`Client]) #Proxy.Handler.t) ~(surface:([`Wl_surface], _, [`Client]) Proxy.t) ~(pointer:([`Wl_pointer], _, [`Client]) Proxy.t) ~(region:([`Wl_region], _, [`Client]) Proxy.t option) ~lifetime =
    let __id = Proxy.spawn _t id in
    let _msg = Proxy.alloc _t ~op:2 ~ints:5 ~strings:[] ~arrays:[] in
    Msg.add_int _msg (Proxy.id __id);
    Msg.add_int _msg (Proxy.id surface);
    Msg.add_int _msg (Proxy.id pointer);
    Msg.add_int _msg (Proxy.id_opt region);
    Msg.add_int _msg (Imports.Zwp_pointer_constraints_v1.Lifetime.to_int32 lifetime);
    Proxy.send _t _msg;
    __id
  
  (** Lock pointer to a position.
      
      The lock_pointer request lets the client request to disable movements of
      the virtual pointer (i.e. the cursor), effectively locking the pointer
      to a position. This request may not take effect immediately; in the
      future, when the compositor deems implementation-specific constraints
      are satisfied, the pointer lock will be activated and the compositor
      sends a locked event.
      
      The protocol provides no guarantee that the constraints are ever
      satisfied, and does not require the compositor to send an error if the
      constraints cannot ever be satisfied. It is thus possible to request a
      lock that will never activate.
      
      There may not be another pointer constraint of any kind requested or
      active on the surface for any of the wl_pointer objects of the seat of
      the passed pointer when requesting a lock. If there is, an error will be
      raised. See general pointer lock documentation for more details.
      
      The intersection of the region passed with this request and the input
      region of the surface is used to determine where the pointer must be
      in order for the lock to activate. It is up to the compositor whether to
      warp the pointer or require some kind of user interaction for the lock
      to activate. If the region is null the surface input region is used.
      
      A surface may receive pointer focus without the lock being activated.
      
      The request creates a new object wp_locked_pointer which is used to
      interact with the lock as well as receive updates about its state. See
      the the description of wp_locked_pointer for further information.
      
      Note that while a pointer is locked, the wl_pointer objects of the
      corresponding seat will not emit any wl_pointer.motion events, but
      relative motion events will still be emitted via wp_relative_pointer
      objects of the same seat. wl_pointer.axis and wl_pointer.button events
      are unaffected. *)
  let lock_pointer (_t:([< `V1] as 'v) t) (id:([`Zwp_locked_pointer_v1], 'v, [`Client]) #Proxy.Handler.t) ~(surface:([`Wl_surface], _, [`Client]) Proxy.t) ~(pointer:([`Wl_pointer], _, [`Client]) Proxy.t) ~(region:([`Wl_region], _, [`Client]) Proxy.t option) ~lifetime =
    let __id = Proxy.spawn _t id in
    let _msg = Proxy.alloc _t ~op:1 ~ints:5 ~strings:[] ~arrays:[] in
    Msg.add_int _msg (Proxy.id __id);
    Msg.add_int _msg (Proxy.id surface);
    Msg.add_int _msg (Proxy.id pointer);
    Msg.add_int _msg (Proxy.id_opt region);
    Msg.add_int _msg (Imports.Zwp_pointer_constraints_v1.Lifetime.to_int32 lifetime);
    Proxy.send _t _msg;
    __id
  
  (** Destroy the pointer constraints manager object.
      
      Used by the client to notify the server that it will no longer use this
      pointer constraints object. *)
  let destroy (_t:([< `V1] as 'v) t)  =
    let _msg = Proxy.alloc _t ~op:0 ~ints:0 ~strings:[] ~arrays:[] in
    Proxy.send _t _msg;
    Proxy.shutdown_send _t
  
  (**/**)
  class ['v] _handlers_unsafe = object (_self : (_, 'v, _) #Proxy.Handler.t)
    method user_data = S.No_data
    method metadata = (module Pointer_constraints_unstable_v1_proto.Zwp_pointer_constraints_v1)
    method max_version = 1l
    
    
    method dispatch (_proxy : 'v t) _msg =
      let _proxy = Proxy.cast_version _proxy in
      match Msg.op _msg with
      | _ -> assert false
  end
  (**/**)
  
  (** {2 Handlers}
      Note: Servers will always want to use [v1].
   *)
  
  
  (** Handler for a proxy with version >= 1. *)
  class ['v] v1 = object (_ : (_, 'v, _) #Proxy.Service_handler.t)
    (**/**)
    inherit [[< `V1] as 'v] _handlers_unsafe
    (**/**)
    method min_version = 1l
    method bind_version : [`V1] = `V1
  end
end

(** Receive relative pointer motion events.
    
    The wp_locked_pointer interface represents a locked pointer state.
    
    While the lock of this object is active, the wl_pointer objects of the
    associated seat will not emit any wl_pointer.motion events.
    
    This object will send the event 'locked' when the lock is activated.
    Whenever the lock is activated, it is guaranteed that the locked surface
    will already have received pointer focus and that the pointer will be
    within the region passed to the request creating this object.
    
    To unlock the pointer, send the destroy request. This will also destroy
    the wp_locked_pointer object.
    
    If the compositor decides to unlock the pointer the unlocked event is
    sent. See wp_locked_pointer.unlock for details.
    
    When unlocking, the compositor may warp the cursor position to the set
    cursor position hint. If it does, it will not result in any relative
    motion events emitted via wp_relative_pointer.
    
    If the surface the lock was requested on is destroyed and the lock is not
    yet activated, the wp_locked_pointer object is now defunct and must be
    destroyed. *)
module Zwp_locked_pointer_v1 = struct
  type 'v t = ([`Zwp_locked_pointer_v1], 'v, [`Client]) Proxy.t
  
  (** {2 Version 1} *)
  
  (** Set a new lock region.
      
      Set a new region used to lock the pointer.
      
      The new lock region is double-buffered. The new lock region will
      only take effect when the associated surface gets its pending state
      applied. See wl_surface.commit for details.
      
      For details about the lock region, see wp_locked_pointer. *)
  let set_region (_t:([< `V1] as 'v) t) ~(region:([`Wl_region], _, [`Client]) Proxy.t option) =
    let _msg = Proxy.alloc _t ~op:2 ~ints:1 ~strings:[] ~arrays:[] in
    Msg.add_int _msg (Proxy.id_opt region);
    Proxy.send _t _msg
  
  (** Set the pointer cursor position hint.
      
      Set the cursor position hint relative to the top left corner of the
      surface.
      
      If the client is drawing its own cursor, it should update the position
      hint to the position of its own cursor. A compositor may use this
      information to warp the pointer upon unlock in order to avoid pointer
      jumps.
      
      The cursor position hint is double buffered. The new hint will only take
      effect when the associated surface gets it pending state applied. See
      wl_surface.commit for details. *)
  let set_cursor_position_hint (_t:([< `V1] as 'v) t) ~surface_x ~surface_y =
    let _msg = Proxy.alloc _t ~op:1 ~ints:2 ~strings:[] ~arrays:[] in
    Msg.add_fixed _msg surface_x;
    Msg.add_fixed _msg surface_y;
    Proxy.send _t _msg
  
  (** Destroy the locked pointer object.
      
      Destroy the locked pointer object. If applicable, the compositor will
      unlock the pointer. *)
  let destroy (_t:([< `V1] as 'v) t)  =
    let _msg = Proxy.alloc _t ~op:0 ~ints:0 ~strings:[] ~arrays:[] in
    Proxy.send _t _msg;
    Proxy.shutdown_send _t
  
  (**/**)
  class virtual ['v] _handlers_unsafe = object (_self : (_, 'v, _) #Proxy.Handler.t)
    method user_data = S.No_data
    method metadata = (module Pointer_constraints_unstable_v1_proto.Zwp_locked_pointer_v1)
    method max_version = 1l
    
    method private virtual on_locked : [> ] t -> unit
    
    method private virtual on_unlocked : [> ] t -> unit
    
    
    method dispatch (_proxy : 'v t) _msg =
      let _proxy = Proxy.cast_version _proxy in
      match Msg.op _msg with
      | 0 ->
        _self#on_locked _proxy 
      | 1 ->
        _self#on_unlocked _proxy 
      | _ -> assert false
  end
  (**/**)
  
  (** {2 Handlers}
      Note: Servers will always want to use [v1].
   *)
  
  
  (** Handler for a proxy with version >= 1. *)
  class virtual ['v] v1 = object (_ : (_, 'v, _) #Proxy.Service_handler.t)
    (**/**)
    inherit [[< `V1] as 'v] _handlers_unsafe
    (**/**)
    method private virtual on_locked : [> `V1] t -> unit
    
    (** Lock activation event.
        
        Notification that the pointer lock of the seat's pointer is activated. *)
    
    method private virtual on_unlocked : [> `V1] t -> unit
    
    (** Lock deactivation event.
        
        Notification that the pointer lock of the seat's pointer is no longer
        active. If this is a oneshot pointer lock (see
        wp_pointer_constraints.lifetime) this object is now defunct and should
        be destroyed. If this is a persistent pointer lock (see
        wp_pointer_constraints.lifetime) this pointer lock may again
        reactivate in the future. *)
    
    method min_version = 1l
  end
end

(** Confined pointer object.
    
    The wp_confined_pointer interface represents a confined pointer state.
    
    This object will send the event 'confined' when the confinement is
    activated. Whenever the confinement is activated, it is guaranteed that
    the surface the pointer is confined to will already have received pointer
    focus and that the pointer will be within the region passed to the request
    creating this object. It is up to the compositor to decide whether this
    requires some user interaction and if the pointer will warp to within the
    passed region if outside.
    
    To unconfine the pointer, send the destroy request. This will also destroy
    the wp_confined_pointer object.
    
    If the compositor decides to unconfine the pointer the unconfined event is
    sent. The wp_confined_pointer object is at this point defunct and should
    be destroyed. *)
module Zwp_confined_pointer_v1 = struct
  type 'v t = ([`Zwp_confined_pointer_v1], 'v, [`Client]) Proxy.t
  
  (** {2 Version 1} *)
  
  (** Set a new confine region.
      
      Set a new region used to confine the pointer.
      
      The new confine region is double-buffered. The new confine region will
      only take effect when the associated surface gets its pending state
      applied. See wl_surface.commit for details.
      
      If the confinement is active when the new confinement region is applied
      and the pointer ends up outside of newly applied region, the pointer may
      warped to a position within the new confinement region. If warped, a
      wl_pointer.motion event will be emitted, but no
      wp_relative_pointer.relative_motion event.
      
      The compositor may also, instead of using the new region, unconfine the
      pointer.
      
      For details about the confine region, see wp_confined_pointer. *)
  let set_region (_t:([< `V1] as 'v) t) ~(region:([`Wl_region], _, [`Client]) Proxy.t option) =
    let _msg = Proxy.alloc _t ~op:1 ~ints:1 ~strings:[] ~arrays:[] in
    Msg.add_int _msg (Proxy.id_opt region);
    Proxy.send _t _msg
  
  (** Destroy the confined pointer object.
      
      Destroy the confined pointer object. If applicable, the compositor will
      unconfine the pointer. *)
  let destroy (_t:([< `V1] as 'v) t)  =
    let _msg = Proxy.alloc _t ~op:0 ~ints:0 ~strings:[] ~arrays:[] in
    Proxy.send _t _msg;
    Proxy.shutdown_send _t
  
  (**/**)
  class virtual ['v] _handlers_unsafe = object (_self : (_, 'v, _) #Proxy.Handler.t)
    method user_data = S.No_data
    method metadata = (module Pointer_constraints_unstable_v1_proto.Zwp_confined_pointer_v1)
    method max_version = 1l
    
    method private virtual on_confined : [> ] t -> unit
    
    method private virtual on_unconfined : [> ] t -> unit
    
    
    method dispatch (_proxy : 'v t) _msg =
      let _proxy = Proxy.cast_version _proxy in
      match Msg.op _msg with
      | 0 ->
        _self#on_confined _proxy 
      | 1 ->
        _self#on_unconfined _proxy 
      | _ -> assert false
  end
  (**/**)
  
  (** {2 Handlers}
      Note: Servers will always want to use [v1].
   *)
  
  
  (** Handler for a proxy with version >= 1. *)
  class virtual ['v] v1 = object (_ : (_, 'v, _) #Proxy.Service_handler.t)
    (**/**)
    inherit [[< `V1] as 'v] _handlers_unsafe
    (**/**)
    method private virtual on_confined : [> `V1] t -> unit
    
    (** Pointer confined.
        
        Notification that the pointer confinement of the seat's pointer is
        activated. *)
    
    method private virtual on_unconfined : [> `V1] t -> unit
    
    (** Pointer unconfined.
        
        Notification that the pointer confinement of the seat's pointer is no
        longer active. If this is a oneshot pointer confinement (see
        wp_pointer_constraints.lifetime) this object is now defunct and should
        be destroyed. If this is a persistent pointer confinement (see
        wp_pointer_constraints.lifetime) this pointer confinement may again
        reactivate in the future. *)
    
    method min_version = 1l
  end
end