whitebreadx 0.1.0

A breadx library that provides a wrapper for libxcb and libX11.
Documentation 
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

//               Copyright John Nunley, 2022.
// Distributed under the Boost Software License, Version 1.0.
//       (See accompanying file LICENSE or copy at
//         https://www.boost.org/LICENSE_1_0.txt)

#![cfg(not(feature = "dl"))]

use super::{
    AuthInfo, Connection, GenericError, GenericEvent, Iovec, ProtocolRequest, Setup, VoidCookie,
    XcbFfi,
};
use libc::{c_char, c_int, c_void};

pub(crate) struct StaticFfi;

unsafe impl XcbFfi for StaticFfi {
    unsafe fn xcb_connect(&self, display: *const c_char, screenp: *mut c_int) -> *mut Connection {
        xcb_connect(display, screenp)
    }

    unsafe fn xcb_connect_to_display_with_auth_info(
        &self,
        display: *const c_char,
        auth_info: *mut AuthInfo,
        screenp: *mut c_int,
    ) -> *mut Connection {
        xcb_connect_to_display_with_auth_info(display, auth_info, screenp)
    }

    unsafe fn xcb_connect_to_fd(&self, fd: c_int, auth_info: *mut AuthInfo) -> *mut Connection {
        xcb_connect_to_fd(fd, auth_info)
    }

    unsafe fn xcb_connection_has_error(&self, conn: *mut Connection) -> c_int {
        xcb_connection_has_error(conn)
    }

    unsafe fn xcb_disconnect(&self, conn: *mut Connection) {
        xcb_disconnect(conn)
    }

    unsafe fn xcb_flush(&self, conn: *mut Connection) -> c_int {
        xcb_flush(conn)
    }

    unsafe fn xcb_generate_id(&self, conn: *mut Connection) -> u32 {
        xcb_generate_id(conn)
    }

    unsafe fn xcb_get_file_descriptor(&self, conn: *mut Connection) -> c_int {
        xcb_get_file_descriptor(conn)
    }

    unsafe fn xcb_get_maximum_request_length(&self, conn: *mut Connection) -> u32 {
        xcb_get_maximum_request_length(conn)
    }

    unsafe fn xcb_get_setup(&self, conn: *mut Connection) -> *mut Setup {
        xcb_get_setup(conn)
    }

    unsafe fn xcb_poll_for_event(&self, conn: *mut Connection) -> *mut GenericEvent {
        xcb_poll_for_event(conn)
    }

    unsafe fn xcb_poll_for_reply64(
        &self,
        conn: *mut Connection,
        seq: u64,
        reply: *mut *mut c_void,
        error: *mut *mut GenericError,
    ) -> c_int {
        xcb_poll_for_reply64(conn, seq, reply, error)
    }

    unsafe fn xcb_send_request64(
        &self,
        conn: *mut Connection,
        flags: c_int,
        iov: *mut Iovec,
        request: *const ProtocolRequest,
    ) -> u64 {
        xcb_send_request64(conn, flags, iov, request)
    }

    unsafe fn xcb_send_request_with_fds64(
        &self,
        conn: *mut Connection,
        flags: c_int,
        iov: *mut Iovec,
        request: *const ProtocolRequest,
        num_fds: c_int,
        fds: *mut c_int,
    ) -> u64 {
        xcb_send_request_with_fds64(conn, flags, iov, request, num_fds, fds)
    }

    unsafe fn xcb_wait_for_event(&self, conn: *mut Connection) -> *mut GenericEvent {
        xcb_wait_for_event(conn)
    }

    unsafe fn xcb_wait_for_reply64(
        &self,
        conn: *mut Connection,
        seq: u64,
        error: *mut *mut GenericError,
    ) -> *mut c_void {
        xcb_wait_for_reply64(conn, seq, error)
    }

    unsafe fn xcb_request_check(
        &self,
        conn: *mut Connection,
        cookie: VoidCookie,
    ) -> *mut GenericError {
        xcb_request_check(conn, cookie)
    }
}

// actual import
#[link(name = "xcb")]
extern "C" {
    fn xcb_connect(display: *const c_char, screenp: *mut c_int) -> *mut Connection;
    fn xcb_connect_to_display_with_auth_info(
        display: *const c_char,
        auth_info: *mut AuthInfo,
        screenp: *mut c_int,
    ) -> *mut Connection;
    fn xcb_connect_to_fd(fd: c_int, auth_info: *mut AuthInfo) -> *mut Connection;
    fn xcb_get_file_descriptor(conn: *mut Connection) -> c_int;
    fn xcb_connection_has_error(conn: *mut Connection) -> c_int;
    fn xcb_disconnect(conn: *mut Connection);
    fn xcb_get_setup(conn: *mut Connection) -> *mut Setup;
    fn xcb_generate_id(conn: *mut Connection) -> u32;
    fn xcb_flush(conn: *mut Connection) -> c_int;
    fn xcb_get_maximum_request_length(conn: *mut Connection) -> u32;
    fn xcb_wait_for_event(conn: *mut Connection) -> *mut GenericEvent;
    fn xcb_poll_for_event(conn: *mut Connection) -> *mut GenericEvent;
    fn xcb_send_request64(
        conn: *mut Connection,
        flags: c_int,
        iov: *mut Iovec,
        request: *const ProtocolRequest,
    ) -> u64;
    fn xcb_send_request_with_fds64(
        conn: *mut Connection,
        flags: c_int,
        iov: *mut Iovec,
        request: *const ProtocolRequest,
        num_fds: c_int,
        fds: *mut c_int,
    ) -> u64;
    fn xcb_wait_for_reply64(
        conn: *mut Connection,
        seq: u64,
        error: *mut *mut GenericError,
    ) -> *mut c_void;
    fn xcb_poll_for_reply64(
        conn: *mut Connection,
        seq: u64,
        reply: *mut *mut c_void,
        error: *mut *mut GenericError,
    ) -> c_int;
    fn xcb_request_check(conn: *mut Connection, cookie: VoidCookie) -> *mut GenericError;
}