Source file pointer_constraints_unstable_v1_server.ml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
[@@@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, [`Server]) 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} *)
(**/**)
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_pointer_constraints_v1)
method max_version = 1l
method private virtual on_destroy : [> ] t -> unit
method private virtual on_lock_pointer : [> ] t -> ([`Zwp_locked_pointer_v1], 'v, [`Server]) Proxy.t ->
surface:([`Wl_surface], [> Imports.Wl_surface.versions], [`Server]) Proxy.t ->
pointer:([`Wl_pointer], [> Imports.Wl_pointer.versions], [`Server]) Proxy.t ->
region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
lifetime:Imports.Zwp_pointer_constraints_v1.Lifetime.t -> unit
method private virtual on_confine_pointer : [> ] t -> ([`Zwp_confined_pointer_v1], 'v, [`Server]) Proxy.t ->
surface:([`Wl_surface], [> Imports.Wl_surface.versions], [`Server]) Proxy.t ->
pointer:([`Wl_pointer], [> Imports.Wl_pointer.versions], [`Server]) Proxy.t ->
region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
lifetime:Imports.Zwp_pointer_constraints_v1.Lifetime.t -> unit
method dispatch (_proxy : 'v t) _msg =
let _proxy = Proxy.cast_version _proxy in
match Msg.op _msg with
| 0 ->
Proxy.shutdown_recv _proxy;
_self#on_destroy _proxy
| 1 ->
let id : ([`Zwp_locked_pointer_v1], _, _) Proxy.t =
Msg.get_int _msg |> Proxy.Handler.accept_new _proxy (module Imports.Zwp_locked_pointer_v1) in
let surface : ([`Wl_surface], _, _) Proxy.t =
let Proxy.Proxy p = Msg.get_int _msg |> Proxy.lookup_other _proxy in
match Proxy.ty p with
| Imports.Wl_surface.T -> p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_surface" p
in
let pointer : ([`Wl_pointer], _, _) Proxy.t =
let Proxy.Proxy p = Msg.get_int _msg |> Proxy.lookup_other _proxy in
match Proxy.ty p with
| Imports.Wl_pointer.T -> p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_pointer" p
in
let region : ([`Wl_region], _, _) Proxy.t option =
match Msg.get_int _msg with
| 0l -> None
| id ->
let Proxy.Proxy p = Proxy.lookup_other _proxy id in
match Proxy.ty p with
| Imports.Wl_region.T -> Some p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_region" p
in
let lifetime = Msg.get_int _msg |> Imports.Zwp_pointer_constraints_v1.Lifetime.of_int32 in
_self#on_lock_pointer _proxy id ~surface ~pointer ~region ~lifetime
| 2 ->
let id : ([`Zwp_confined_pointer_v1], _, _) Proxy.t =
Msg.get_int _msg |> Proxy.Handler.accept_new _proxy (module Imports.Zwp_confined_pointer_v1) in
let surface : ([`Wl_surface], _, _) Proxy.t =
let Proxy.Proxy p = Msg.get_int _msg |> Proxy.lookup_other _proxy in
match Proxy.ty p with
| Imports.Wl_surface.T -> p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_surface" p
in
let pointer : ([`Wl_pointer], _, _) Proxy.t =
let Proxy.Proxy p = Msg.get_int _msg |> Proxy.lookup_other _proxy in
match Proxy.ty p with
| Imports.Wl_pointer.T -> p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_pointer" p
in
let region : ([`Wl_region], _, _) Proxy.t option =
match Msg.get_int _msg with
| 0l -> None
| id ->
let Proxy.Proxy p = Proxy.lookup_other _proxy id in
match Proxy.ty p with
| Imports.Wl_region.T -> Some p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_region" p
in
let lifetime = Msg.get_int _msg |> Imports.Zwp_pointer_constraints_v1.Lifetime.of_int32 in
_self#on_confine_pointer _proxy id ~surface ~pointer ~region ~lifetime
| _ -> 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_destroy : [> `V1] t -> unit
(** Destroy the pointer constraints manager object.
Used by the client to notify the server that it will no longer use this
pointer constraints object. *)
method private virtual on_lock_pointer : [> `V1] t -> ([`Zwp_locked_pointer_v1], 'v, [`Server]) Proxy.t ->
surface:([`Wl_surface], [> Imports.Wl_surface.versions], [`Server]) Proxy.t ->
pointer:([`Wl_pointer], [> Imports.Wl_pointer.versions], [`Server]) Proxy.t ->
region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
lifetime:Imports.Zwp_pointer_constraints_v1.Lifetime.t -> unit
(** 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. *)
method private virtual on_confine_pointer : [> `V1] t -> ([`Zwp_confined_pointer_v1], 'v, [`Server]) Proxy.t ->
surface:([`Wl_surface], [> Imports.Wl_surface.versions], [`Server]) Proxy.t ->
pointer:([`Wl_pointer], [> Imports.Wl_pointer.versions], [`Server]) Proxy.t ->
region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
lifetime:Imports.Zwp_pointer_constraints_v1.Lifetime.t -> unit
(** 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. *)
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, [`Server]) Proxy.t
(** {2 Version 1} *)
(** 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. *)
let unlocked (_t:([< `V1] as 'v) t) =
let _msg = Proxy.alloc _t ~op:1 ~ints:0 ~strings:[] ~arrays:[] in
Proxy.send _t _msg
(** Lock activation event.
Notification that the pointer lock of the seat's pointer is activated. *)
let locked (_t:([< `V1] as 'v) t) =
let _msg = Proxy.alloc _t ~op:0 ~ints:0 ~strings:[] ~arrays:[] in
Proxy.send _t _msg
(**/**)
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_destroy : [> ] t -> unit
method private virtual on_set_cursor_position_hint : [> ] t -> surface_x:Fixed.t -> surface_y:Fixed.t -> unit
method private virtual on_set_region : [> ] t -> region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
unit
method dispatch (_proxy : 'v t) _msg =
let _proxy = Proxy.cast_version _proxy in
match Msg.op _msg with
| 0 ->
Proxy.shutdown_recv _proxy;
_self#on_destroy _proxy
| 1 ->
let surface_x = Msg.get_fixed _msg in
let surface_y = Msg.get_fixed _msg in
_self#on_set_cursor_position_hint _proxy ~surface_x ~surface_y
| 2 ->
let region : ([`Wl_region], _, _) Proxy.t option =
match Msg.get_int _msg with
| 0l -> None
| id ->
let Proxy.Proxy p = Proxy.lookup_other _proxy id in
match Proxy.ty p with
| Imports.Wl_region.T -> Some p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_region" p
in
_self#on_set_region _proxy ~region
| _ -> 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_destroy : [> `V1] t -> unit
(** Destroy the locked pointer object.
Destroy the locked pointer object. If applicable, the compositor will
unlock the pointer. *)
method private virtual on_set_cursor_position_hint : [> `V1] t -> surface_x:Fixed.t -> surface_y:Fixed.t -> unit
(** 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. *)
method private virtual on_set_region : [> `V1] t -> region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
unit
(** 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. *)
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, [`Server]) Proxy.t
(** {2 Version 1} *)
(** 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. *)
let unconfined (_t:([< `V1] as 'v) t) =
let _msg = Proxy.alloc _t ~op:1 ~ints:0 ~strings:[] ~arrays:[] in
Proxy.send _t _msg
(** Pointer confined.
Notification that the pointer confinement of the seat's pointer is
activated. *)
let confined (_t:([< `V1] as 'v) t) =
let _msg = Proxy.alloc _t ~op:0 ~ints:0 ~strings:[] ~arrays:[] in
Proxy.send _t _msg
(**/**)
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_destroy : [> ] t -> unit
method private virtual on_set_region : [> ] t -> region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
unit
method dispatch (_proxy : 'v t) _msg =
let _proxy = Proxy.cast_version _proxy in
match Msg.op _msg with
| 0 ->
Proxy.shutdown_recv _proxy;
_self#on_destroy _proxy
| 1 ->
let region : ([`Wl_region], _, _) Proxy.t option =
match Msg.get_int _msg with
| 0l -> None
| id ->
let Proxy.Proxy p = Proxy.lookup_other _proxy id in
match Proxy.ty p with
| Imports.Wl_region.T -> Some p
| _ -> Proxy.wrong_type ~parent:_proxy ~expected:"wl_region" p
in
_self#on_set_region _proxy ~region
| _ -> 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_destroy : [> `V1] t -> unit
(** Destroy the confined pointer object.
Destroy the confined pointer object. If applicable, the compositor will
unconfine the pointer. *)
method private virtual on_set_region : [> `V1] t -> region:([`Wl_region], [> Imports.Wl_region.versions], [`Server]) Proxy.t option ->
unit
(** 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. *)
method min_version = 1l
end
end