Description

This file gets generated using the zig-wayland Scanner at build time and placed in the zig-cache/o directory.

27const scanner = Scanner.create(b, .{});
28const wayland = b.createModule(.{ .source_file = scanner.result });
29
30scanner.generate("wl_compositor", 1);
31
32exe.addModule("wayland", wayland);
33exe.linkLibC();
34exe.linkSystemLibrary("wayland-client");

Contents

  1// Generated by zig-wayland
  2
  3// Copyright © 2008-2011 Kristian Høgsberg
  4// Copyright © 2010-2011 Intel Corporation
  5// Copyright © 2012-2013 Collabora, Ltd.
  6//
  7// Permission is hereby granted, free of charge, to any person
  8// obtaining a copy of this software and associated documentation files
  9// (the "Software"), to deal in the Software without restriction,
 10// including without limitation the rights to use, copy, modify, merge,
 11// publish, distribute, sublicense, and/or sell copies of the Software,
 12// and to permit persons to whom the Software is furnished to do so,
 13// subject to the following conditions:
 14//
 15// The above copyright notice and this permission notice (including the
 16// next paragraph) shall be included in all copies or substantial
 17// portions of the Software.
 18//
 19// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 21// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22// NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 23// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 24// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 25// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 26// SOFTWARE.
 27//
 28
 29const std = @import("std");
 30const os = std.os;
 31const client = @import("wayland.zig").client;
 32const common = @import("common.zig");
 33pub const Display = opaque {
 34    pub const generated_version = 1;
 35    pub const getInterface = common.wl.display.getInterface;
 36    pub const Error = common.wl.display.Error;
 37    pub fn setQueue(_display: *Display, _queue: *client.wl.EventQueue) void {
 38        const _proxy: *client.wl.Proxy = @ptrCast(_display);
 39        _proxy.setQueue(_queue);
 40    }
 41    pub const Event = union(enum) {
 42        @"error": struct {
 43            object_id: ?*common.Object,
 44            code: u32,
 45            message: [*:0]const u8,
 46        },
 47        delete_id: struct {
 48            id: u32,
 49        },
 50    };
 51    pub inline fn setListener(
 52        _display: *Display,
 53        comptime T: type,
 54        _listener: *const fn (display: *Display, event: Event, data: T) void,
 55        _data: T,
 56    ) void {
 57        const _proxy: *client.wl.Proxy = @ptrCast(_display);
 58        const _mut_data: ?*anyopaque = @ptrFromInt(@intFromPtr(_data));
 59        _proxy.addDispatcher(common.Dispatcher(Display, T).dispatcher, _listener, _mut_data);
 60    }
 61    pub fn sync(_display: *Display) !*client.wl.Callback {
 62        const _proxy: *client.wl.Proxy = @ptrCast(_display);
 63        var _args = [_]common.Argument{
 64            .{ .o = null },
 65        };
 66        return @ptrCast(try _proxy.marshalConstructor(0, &_args, client.wl.Callback.getInterface()));
 67    }
 68    pub fn getRegistry(_display: *Display) !*client.wl.Registry {
 69        const _proxy: *client.wl.Proxy = @ptrCast(_display);
 70        var _args = [_]common.Argument{
 71            .{ .o = null },
 72        };
 73        return @ptrCast(try _proxy.marshalConstructor(1, &_args, client.wl.Registry.getInterface()));
 74    }
 75    extern fn wl_display_connect(name: ?[*:0]const u8) ?*Display;
 76    pub inline fn connect(name: ?[*:0]const u8) error{ConnectFailed}!*Display {
 77        return wl_display_connect(name) orelse return error.ConnectFailed;
 78    }
 79
 80    extern fn wl_display_connect_to_fd(fd: c_int) ?*Display;
 81    pub inline fn connectToFd(fd: c_int) error{ConnectFailed}!*Display {
 82        return wl_display_connect_to_fd(fd) orelse return error.ConnectFailed;
 83    }
 84
 85    extern fn wl_display_disconnect(display: *Display) void;
 86    pub const disconnect = wl_display_disconnect;
 87
 88    extern fn wl_display_get_fd(display: *Display) c_int;
 89    pub const getFd = wl_display_get_fd;
 90
 91    extern fn wl_display_dispatch(display: *Display) c_int;
 92    pub inline fn dispatch(display: *Display) os.E {
 93        return os.errno(wl_display_dispatch(display));
 94    }
 95
 96    extern fn wl_display_dispatch_queue(display: *Display, queue: *client.wl.EventQueue) c_int;
 97    pub inline fn dispatchQueue(display: *Display, queue: *client.wl.EventQueue) os.E {
 98        return os.errno(wl_display_dispatch_queue(display, queue));
 99    }
100
101    extern fn wl_display_dispatch_pending(display: *Display) c_int;
102    pub inline fn dispatchPending(display: *Display) os.E {
103        return os.errno(wl_display_dispatch_pending(display));
104    }
105
106    extern fn wl_display_dispatch_queue_pending(display: *Display, queue: *client.wl.EventQueue) c_int;
107    pub inline fn dispatchQueuePending(display: *Display, queue: *client.wl.EventQueue) os.E {
108        return os.errno(wl_display_dispatch_queue_pending(display, queue));
109    }
110
111    extern fn wl_display_roundtrip(display: *Display) c_int;
112    pub inline fn roundtrip(display: *Display) os.E {
113        return os.errno(wl_display_roundtrip(display));
114    }
115
116    extern fn wl_display_roundtrip_queue(display: *Display, queue: *client.wl.EventQueue) c_int;
117    pub inline fn roundtripQueue(display: *Display, queue: *client.wl.EventQueue) os.E {
118        return os.errno(wl_display_roundtrip_queue(display, queue));
119    }
120
121    extern fn wl_display_flush(display: *Display) c_int;
122    pub inline fn flush(display: *Display) os.E {
123        return os.errno(wl_display_flush(display));
124    }
125
126    extern fn wl_display_create_queue(display: *Display) ?*client.wl.EventQueue;
127    pub inline fn createQueue(display: *Display) error{OutOfMemory}!*client.wl.EventQueue {
128        return wl_display_create_queue(display) orelse error.OutOfMemory;
129    }
130
131    extern fn wl_display_get_error(display: *Display) c_int;
132    pub const getError = wl_display_get_error;
133
134    extern fn wl_display_prepare_read_queue(display: *Display, queue: *client.wl.EventQueue) c_int;
135    /// Succeeds if the queue is empty and returns true.
136    /// Fails and returns false if the queue was not empty.
137    pub inline fn prepareReadQueue(display: *Display, queue: *client.wl.EventQueue) bool {
138        switch (wl_display_prepare_read_queue(display, queue)) {
139            0 => return true,
140            -1 => return false,
141            else => unreachable,
142        }
143    }
144
145    extern fn wl_display_prepare_read(display: *Display) c_int;
146    /// Succeeds if the queue is empty and returns true.
147    /// Fails and returns false if the queue was not empty.
148    pub inline fn prepareRead(display: *Display) bool {
149        switch (wl_display_prepare_read(display)) {
150            0 => return true,
151            -1 => return false,
152            else => unreachable,
153        }
154    }
155
156    extern fn wl_display_cancel_read(display: *Display) void;
157    pub const cancelRead = wl_display_cancel_read;
158
159    extern fn wl_display_read_events(display: *Display) c_int;
160    pub inline fn readEvents(display: *Display) os.E {
161        return os.errno(wl_display_read_events(display));
162    }
163};
164pub const Registry = opaque {
165    pub const generated_version = 1;
166    pub const getInterface = common.wl.registry.getInterface;
167    pub fn setQueue(_registry: *Registry, _queue: *client.wl.EventQueue) void {
168        const _proxy: *client.wl.Proxy = @ptrCast(_registry);
169        _proxy.setQueue(_queue);
170    }
171    pub const Event = union(enum) {
172        global: struct {
173            name: u32,
174            interface: [*:0]const u8,
175            version: u32,
176        },
177        global_remove: struct {
178            name: u32,
179        },
180    };
181    pub inline fn setListener(
182        _registry: *Registry,
183        comptime T: type,
184        _listener: *const fn (registry: *Registry, event: Event, data: T) void,
185        _data: T,
186    ) void {
187        const _proxy: *client.wl.Proxy = @ptrCast(_registry);
188        const _mut_data: ?*anyopaque = @ptrFromInt(@intFromPtr(_data));
189        _proxy.addDispatcher(common.Dispatcher(Registry, T).dispatcher, _listener, _mut_data);
190    }
191    pub fn bind(_registry: *Registry, _name: u32, comptime T: type, _version: u32) !*T {
192        const version_to_construct = @min(T.generated_version, _version);
193        const _proxy: *client.wl.Proxy = @ptrCast(_registry);
194        var _args = [_]common.Argument{
195            .{ .u = _name },                .{ .s = T.getInterface().name },
196            .{ .u = version_to_construct }, .{ .o = null },
197        };
198        return @ptrCast(try _proxy.marshalConstructorVersioned(0, &_args, T.getInterface(), version_to_construct));
199    }
200    pub fn destroy(_registry: *Registry) void {
201        const _proxy: *client.wl.Proxy = @ptrCast(_registry);
202        _proxy.destroy();
203    }
204};
205pub const Callback = opaque {
206    pub const generated_version = 1;
207    pub const getInterface = common.wl.callback.getInterface;
208    pub fn setQueue(_callback: *Callback, _queue: *client.wl.EventQueue) void {
209        const _proxy: *client.wl.Proxy = @ptrCast(_callback);
210        _proxy.setQueue(_queue);
211    }
212    pub const Event = union(enum) {
213        done: struct {
214            callback_data: u32,
215        },
216    };
217    pub inline fn setListener(
218        _callback: *Callback,
219        comptime T: type,
220        _listener: *const fn (callback: *Callback, event: Event, data: T) void,
221        _data: T,
222    ) void {
223        const _proxy: *client.wl.Proxy = @ptrCast(_callback);
224        const _mut_data: ?*anyopaque = @ptrFromInt(@intFromPtr(_data));
225        _proxy.addDispatcher(common.Dispatcher(Callback, T).dispatcher, _listener, _mut_data);
226    }
227    pub fn destroy(_callback: *Callback) void {
228        const _proxy: *client.wl.Proxy = @ptrCast(_callback);
229        _proxy.destroy();
230    }
231};
232pub const Buffer = opaque {
233    pub const generated_version = 1;
234    pub const getInterface = common.wl.buffer.getInterface;
235    pub fn setQueue(_buffer: *Buffer, _queue: *client.wl.EventQueue) void {
236        const _proxy: *client.wl.Proxy = @ptrCast(_buffer);
237        _proxy.setQueue(_queue);
238    }
239    pub const Event = union(enum) {
240        release: void,
241    };
242    pub inline fn setListener(
243        _buffer: *Buffer,
244        comptime T: type,
245        _listener: *const fn (buffer: *Buffer, event: Event, data: T) void,
246        _data: T,
247    ) void {
248        const _proxy: *client.wl.Proxy = @ptrCast(_buffer);
249        const _mut_data: ?*anyopaque = @ptrFromInt(@intFromPtr(_data));
250        _proxy.addDispatcher(common.Dispatcher(Buffer, T).dispatcher, _listener, _mut_data);
251    }
252    pub fn destroy(_buffer: *Buffer) void {
253        const _proxy: *client.wl.Proxy = @ptrCast(_buffer);
254        _proxy.marshal(0, null);
255        _proxy.destroy();
256    }
257};
258pub const Compositor = opaque {
259    pub const generated_version = 1;
260    pub const getInterface = common.wl.compositor.getInterface;
261    pub fn setQueue(_compositor: *Compositor, _queue: *client.wl.EventQueue) void {
262        const _proxy: *client.wl.Proxy = @ptrCast(_compositor);
263        _proxy.setQueue(_queue);
264    }
265    pub fn createSurface(_compositor: *Compositor) !*client.wl.Surface {
266        const _proxy: *client.wl.Proxy = @ptrCast(_compositor);
267        var _args = [_]common.Argument{
268            .{ .o = null },
269        };
270        return @ptrCast(try _proxy.marshalConstructor(0, &_args, client.wl.Surface.getInterface()));
271    }
272    pub fn createRegion(_compositor: *Compositor) !*client.wl.Region {
273        const _proxy: *client.wl.Proxy = @ptrCast(_compositor);
274        var _args = [_]common.Argument{
275            .{ .o = null },
276        };
277        return @ptrCast(try _proxy.marshalConstructor(1, &_args, client.wl.Region.getInterface()));
278    }
279    pub fn destroy(_compositor: *Compositor) void {
280        const _proxy: *client.wl.Proxy = @ptrCast(_compositor);
281        _proxy.destroy();
282    }
283};
284pub const Surface = opaque {
285    pub const generated_version = 1;
286    pub const getInterface = common.wl.surface.getInterface;
287    pub const Error = common.wl.surface.Error;
288    pub fn setQueue(_surface: *Surface, _queue: *client.wl.EventQueue) void {
289        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
290        _proxy.setQueue(_queue);
291    }
292    pub const Event = union(enum) {
293        enter: struct {
294            output: ?*client.wl.Output,
295        },
296        leave: struct {
297            output: ?*client.wl.Output,
298        },
299    };
300    pub inline fn setListener(
301        _surface: *Surface,
302        comptime T: type,
303        _listener: *const fn (surface: *Surface, event: Event, data: T) void,
304        _data: T,
305    ) void {
306        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
307        const _mut_data: ?*anyopaque = @ptrFromInt(@intFromPtr(_data));
308        _proxy.addDispatcher(common.Dispatcher(Surface, T).dispatcher, _listener, _mut_data);
309    }
310    pub fn destroy(_surface: *Surface) void {
311        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
312        _proxy.marshal(0, null);
313        _proxy.destroy();
314    }
315    pub fn attach(_surface: *Surface, _buffer: ?*client.wl.Buffer, _x: i32, _y: i32) void {
316        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
317        var _args = [_]common.Argument{
318            .{ .o = @ptrCast(_buffer) },
319            .{ .i = _x },
320            .{ .i = _y },
321        };
322        _proxy.marshal(1, &_args);
323    }
324    pub fn damage(_surface: *Surface, _x: i32, _y: i32, _width: i32, _height: i32) void {
325        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
326        var _args = [_]common.Argument{
327            .{ .i = _x },
328            .{ .i = _y },
329            .{ .i = _width },
330            .{ .i = _height },
331        };
332        _proxy.marshal(2, &_args);
333    }
334    pub fn frame(_surface: *Surface) !*client.wl.Callback {
335        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
336        var _args = [_]common.Argument{
337            .{ .o = null },
338        };
339        return @ptrCast(try _proxy.marshalConstructor(3, &_args, client.wl.Callback.getInterface()));
340    }
341    pub fn setOpaqueRegion(_surface: *Surface, _region: ?*client.wl.Region) void {
342        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
343        var _args = [_]common.Argument{
344            .{ .o = @ptrCast(_region) },
345        };
346        _proxy.marshal(4, &_args);
347    }
348    pub fn setInputRegion(_surface: *Surface, _region: ?*client.wl.Region) void {
349        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
350        var _args = [_]common.Argument{
351            .{ .o = @ptrCast(_region) },
352        };
353        _proxy.marshal(5, &_args);
354    }
355    pub fn commit(_surface: *Surface) void {
356        const _proxy: *client.wl.Proxy = @ptrCast(_surface);
357        _proxy.marshal(6, null);
358    }
359};
360pub const Region = opaque {
361    pub const generated_version = 1;
362    pub const getInterface = common.wl.region.getInterface;
363    pub fn setQueue(_region: *Region, _queue: *client.wl.EventQueue) void {
364        const _proxy: *client.wl.Proxy = @ptrCast(_region);
365        _proxy.setQueue(_queue);
366    }
367    pub fn destroy(_region: *Region) void {
368        const _proxy: *client.wl.Proxy = @ptrCast(_region);
369        _proxy.marshal(0, null);
370        _proxy.destroy();
371    }
372    pub fn add(_region: *Region, _x: i32, _y: i32, _width: i32, _height: i32) void {
373        const _proxy: *client.wl.Proxy = @ptrCast(_region);
374        var _args = [_]common.Argument{
375            .{ .i = _x },
376            .{ .i = _y },
377            .{ .i = _width },
378            .{ .i = _height },
379        };
380        _proxy.marshal(1, &_args);
381    }
382    pub fn subtract(_region: *Region, _x: i32, _y: i32, _width: i32, _height: i32) void {
383        const _proxy: *client.wl.Proxy = @ptrCast(_region);
384        var _args = [_]common.Argument{
385            .{ .i = _x },
386            .{ .i = _y },
387            .{ .i = _width },
388            .{ .i = _height },
389        };
390        _proxy.marshal(2, &_args);
391    }
392};