xcb.zig/example.zig at master · MidstallSoftware/xcb.zig · GitHub

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
const std = @import("std");
const xcb = @import("xcb");

pub fn main() !void {
    const alloc = std.heap.c_allocator;

    var screenId: c_int = 0;

    const conn = try xcb.Connection.connect(null, &screenId);
    defer conn.disconnect();

    const setup = conn.getSetup();
    const screen = blk: {
        var iter = setup.rootsIterator();
        var i: usize = 0;
        while (iter.next()) |screen| : (i += 1) {
            if (i == screenId) break :blk screen;
        }
        @panic("Cannot locate screen");
    };

    const monitors = try xcb.randr.getMonitors(conn, screen.root, 0).reply(conn);
    var monitorsIter = monitors.monitorsIterator();

    while (monitorsIter.next()) |monitor| {
        std.debug.print("{} {}\n", .{ monitor, @sizeOf(@TypeOf(monitor)) });
        for (monitor.outputs()) |output| {
            const outputInfo = try xcb.randr.getOutputInfo(conn, output, 0).reply(conn);
            std.debug.print("{} {}\n", .{ outputInfo, @sizeOf(@TypeOf(outputInfo.*)) });

            const crtcInfo = try xcb.randr.getCrtcInfo(conn, outputInfo.crtc, 0).reply(conn);
            std.debug.print("{} {}\n", .{ crtcInfo, @sizeOf(@TypeOf(crtcInfo.*)) });
        }
    }

    const win = xcb.xproto.WINDOW{ .value = try conn.generateId() };
    if (conn.requestCheck(xcb.xproto.createWindow(
        conn,
        screen.root_depth,
        win,
        screen.root,
        0,
        0,
        100,
        100,
        0,
        1,
        screen.root_visual,
        1 << xcb.xproto.CW.BackPixel | 1 << xcb.xproto.CW.EventMask,
        &[_]u32{ screen.black_pixel, 1 << 15 },
    ))) |_| return error.GenericError;

    if (conn.requestCheck(xcb.xproto.mapWindow(
        conn,
        win,
    ))) |_| return error.GenericError;

    try conn.flush();

    const pixmap = xcb.xproto.PIXMAP{ .value = try conn.generateId() };
    if (conn.requestCheck(xcb.xproto.createPixmap(
        conn,
        screen.root_depth,
        pixmap,
        .{ .window = win },
        100,
        100,
    ))) |_| return error.GenericError;

    const gc = xcb.xproto.GCONTEXT{ .value = try conn.generateId() };
    if (conn.requestCheck(xcb.xproto.createGC(
        conn,
        gc,
        .{ .pixmap = pixmap },
        1 << xcb.xproto.GC.Foreground | 1 << xcb.xproto.GC.Background,
        &[_]u32{ screen.black_pixel, screen.white_pixel },
    ))) |_| return error.GenericError;

    const fb = try alloc.alloc(u8, 100 * 100 * 4);
    defer alloc.free(fb);
    @memset(fb, 0xff);

    if (conn.requestCheck(xcb.xproto.putImage(
        conn,
        2,
        .{ .pixmap = pixmap },
        gc,
        100,
        100,
        0,
        0,
        screen.root_depth,
        0,
        0,
        fb.ptr,
    ))) |_| return error.GenericError;

    if (conn.requestCheck(xcb.xproto.copyArea(
        conn,
        .{ .pixmap = pixmap },
        .{ .window = win },
        gc,
        0,
        0,
        0,
        0,
        100,
        100,
    ))) |_| return error.GenericError;

    while (conn.waitForEvent() catch null) |ev| {
        if (ev.response_type == 12) {
            const exposeEvent: *xcb.xproto.events.Expose = @ptrCast(@alignCast(ev));
            std.debug.print("{}\n", .{exposeEvent});
        }
    }
}