logo

drewdevault.com

[mirror] blog and personal website of Drew DeVault git clone https://hacktivis.me/git/mirror/drewdevault.com.git

Writing-a-wayland-compositor-part-2.md (6657B)

    

  1. ---
  2. date: 2018-02-22
  3. title: "Writing a Wayland Compositor, Part 2: Rigging up the server"
  4. layout: post
  5. tags: [wayland, wlroots, instructional]
  6. ---
  8. This is the second in a series of articles on the subject of writing a Wayland
  9. compositor from scratch using [wlroots](https://github.com/swaywm/wlroots).
  10. Check out [the first article](/2018/02/17/Writing-a-Wayland-compositor-1.html)
  11. if you haven't already. Last time, we ended up with an application which fired
  12. up a wlroots backend, enumerated output devices, and drew some pretty colors on
  13. the screen. Today, we're going to start accepting Wayland client connections,
  14. though we aren't going to be doing much with them yet.
  16. The commit that this article dissects is
  17. [b45c651](https://github.com/SirCmpwn/mcwayland/commit/b45c651).
  19. A quick aside on the nature of these blog posts: it's going to take *a lot* of
  20. these articles to flesh out our compositor. I'm going to be publishing these
  21. more frequently than usual, probably 1-2 per week, and continue posting my usual
  22. articles at the typical rate. Okay? Cool.
  24. So we've started up the backend and we're rendering something interesting, but
  25. we still aren't running a Wayland server -- Wayland clients aren't connecting to
  26. our application. Adding this is actually quite easy:
  28. ```diff
  29. @@ -113,12 +113,18 @@ int main(int argc, char **argv) {
  30.         server.new_output.notify = new_output_notify;
  31.         wl_signal_add(&server.backend->events.new_output, &server.new_output);
  32.  
  33. +       const char *socket = wl_display_add_socket_auto(server.wl_display);
  34. +       assert(socket);
  35. +
  36.         if (!wlr_backend_start(server.backend)) {
  37.                 fprintf(stderr, "Failed to start backend\n");
  38.                 wl_display_destroy(server.wl_display);
  39.                 return 1;
  40.         }
  41.  
  42. +       printf("Running compositor on wayland display '%s'\n", socket);
  43. +       setenv("WAYLAND_DISPLAY", socket, true);
  44. +
  45.         wl_display_run(server.wl_display);
  46.         wl_display_destroy(server.wl_display);
  47.         return 0;
  48. ```
  50. That's it! If you run McWayface again, it'll print something like this:
  52. ```
  53. Running compositor on wayland display 'wayland-1'
  54. ```
  56. [Weston](https://cgit.freedesktop.org/wayland/weston/), the Wayland reference
  57. compositor, includes a number of simple reference clients. We can use
  58. `weston-info` to connect to our server and list the **globals**:
  60. ```
  61. $ WAYLAND_DISPLAY=wayland-1 weston-info
  62. interface: 'wl_drm', version: 2, name: 1
  63. ```
  65. If you recall from my [Introduction to
  66. Wayland](/2017/06/10/Introduction-to-Wayland.html), the Wayland server exports a
  67. list of **globals** to clients via the Wayland registry. These globals provide
  68. interfaces the client can utilize to interact with the server. We get `wl_drm`
  69. for free with wlroots, but we have not actually wired up anything useful yet.
  70. Wlroots provides many "types", of which the majority are implementations of
  71. Wayland global interfaces like this.
  73. Some of the wlroots implementations require some rigging from you, but several
  74. of them just take care of themselves. Rigging these up is easy:
  76. ```diff
  77.         printf("Running compositor on wayland display '%s'\n", socket);
  78.         setenv("WAYLAND_DISPLAY", socket, true);
  79. +
  80. +       wl_display_init_shm(server.wl_display);
  81. +       wlr_gamma_control_manager_create(server.wl_display);
  82. +       wlr_screenshooter_create(server.wl_display);
  83. +       wlr_primary_selection_device_manager_create(server.wl_display);
  84. +       wlr_idle_create(server.wl_display);
  85.  
  86.         wl_display_run(server.wl_display);
  87.         wl_display_destroy(server.wl_display);
  88. ```
  90. Note that some of these interfaces are not necessarily ones that you typically
  91. would want to expose to all Wayland clients - screenshooter, for example, is
  92. something that should be secured. We'll get to security in a later article. For
  93. now, if we run `weston-info` again, we'll see a few more globals have appeared:
  95. ```
  96. $ WAYLAND_DISPLAY=wayland-1 weston-info
  97. interface: 'wl_shm', version: 1, name: 3
  98. 	formats: XRGB8888 ARGB8888
  99. interface: 'wl_drm', version: 2, name: 1
  100. interface: 'gamma_control_manager', version: 1, name: 2
  101. interface: 'orbital_screenshooter', version: 1, name: 3
  102. interface: 'gtk_primary_selection_device_manager', version: 1, name: 4
  103. interface: 'org_kde_kwin_idle', version: 1, name: 5
  104. ```
  106. You'll find that wlroots implements a variety of protocols from a variety of
  107. sources - here we see protocols from Orbital, GTK, and KDE represented. Wlroots
  108. includes an example client for the orbital screenshooter - we can use it now to
  109. take a screenshot of our compositor:
  111. ```
  112. $ WAYLAND_DISPLAY=wayland-1 ./examples/screenshot
  113. cannot set buffer size
  114. ```
  116. Ah, this is a problem - you may have noticed that we don't have any wl_output
  117. globals, which the screenshooter client relies on to figure out the resolution
  118. of the screenshot buffer. We can add these, too:
  120. ```diff
  121. @@ -95,6 +99,8 @@ static void new_output_notify(struct wl_listener *listener, void *data) {
  122.         wl_signal_add(&wlr_output->events.destroy, &output->destroy);
  123.         output->frame.notify = output_frame_notify;
  124.         wl_signal_add(&wlr_output->events.frame, &output->frame);
  125. +
  126. +       wlr_output_create_global(wlr_output);
  127.  }
  128. ```
  130. Running `weston-info` again will give us some info about our outputs now:
  132. ```
  133. $ WAYLAND_DISPLAY=wayland-1 weston-info
  134. interface: 'wl_drm', version: 2, name: 1
  135. interface: 'wl_output', version: 3, name: 2
  136. 	x: 0, y: 0, scale: 1,
  137. 	physical_width: 0 mm, physical_height: 0 mm,
  138. 	make: 'wayland', model: 'wayland',
  139. 	subpixel_orientation: unknown, output_transform: normal,
  140. 	mode:
  141. 		width: 952 px, height: 521 px, refresh: 0.000 Hz,
  142. 		flags: current
  143. interface: 'wl_shm', version: 1, name: 3
  144. 	formats: XRGB8888 ARGB8888
  145. interface: 'gamma_control_manager', version: 1, name: 4
  146. interface: 'orbital_screenshooter', version: 1, name: 5
  147. interface: 'gtk_primary_selection_device_manager', version: 1, name: 6
  148. interface: 'org_kde_kwin_idle', version: 1, name: 7
  149. ```
  151. Now we can take that screenshot! Give it a shot (heh)!
  153. We're getting close to the good stuff now. The next article is going to
  154. introduce the concept of **surfaces**, and we will use them to render our first
  155. window. If you had any trouble with this article, please reach out to me at
  156. [sir@cmpwn.com](mailto:sir@cmpwn.com) or to the wlroots team at
  157. [#sway-devel](http://webchat.freenode.net/?channels=sway-devel&uio=d4).
  159. <p style="float: right">
  160.     Next &mdash;
  161.     <a href="/2018/02/28/Writing-a-wayland-compositor-part-3.html">
  162.         Part 3: Rendering a window
  163.     </a>
  164. </p>
  165. <p>
  166.     Previous &mdash;
  167.     <a href="/2018/02/17/Writing-a-Wayland-compositor-1.html">
  168.         Part 1: Hello wlroots
  169.     </a>
  170. </p>