Category: Wayland

  • Recent development in Enlightenment’s Wayland compositor has focused on implementing cross-desktop protocols and improving stability. One of the recently handled protocol series has been relative and constrained pointers. Relative pointer motion is a method for providing pointer movement deltas directly to applications. This is useful for a number of cases, though the easiest to imagine might be first person shooter games. In this case, the application receives movement deltas, allowing the player to endlessly scroll the screen in one direction without hitting the boundaries of the screen. Under Enlightenment, this is handled in different ways depending on the output backend being used. For backends using libinput, e.g., DRM, it’s possible to get relative motion deltas directly from the events and then emit them for compositor use. Other backends, however, such as nested Wayland compositors, have no access to libinput’s hardware events. In this case, Enlightenment must manually calculate the deltas […]

    Read More
  • February 2, 2017 - Derek Foreman

    A Curious Wayland Bug

    Enlightenment has a slightly unconventional architecture. For many of its internal dialogues (settings, the file manager, etc.) it uses what we call “internal windows.” These are simply regular toolkit windows that use regular rendering back-ends; in the good ol’ days, this meant a connection to the X server which resulted in a render to a standard X window. In this scenario, the compositor gets the result back the same way as all X client windows, and it composites all internal and external windows together. Under Wayland, things get a bit scarier because now the compositor is the display server. Enlightenment makes a Wayland connection to itself; this gives us all manner of game winning capabilities we never had before. For example, let’s say the internal window wants to sleep and wait for a reply from the compositor (such as a released buffer to render the next frame into). We deadlock and fall down […]

    Read More
  • While there are some developers who are familiar with using Ecore_Evas to create a canvas for applications, we often find that new EFL users face some confusion when first trying to create an application. This article aims to provide a simple example of how to create your first EFL Wayland application. For those not familiar with the Ecore_Evas library, it is a set of functions that make it easy to tie together Ecore’s main loop and input handling to Evas; as such, it’s a natural base for EFL applications. While this combination makes it easy to create the basic aspects all applications need, for normal applications (those that use buttons, checkboxes and layouts) one should consider using Elementary. Ecore_Evas is extremely well suited for applications that are not based on widgets. It has a main loop that delivers events, does basic window handling, and leaves all of the drawing up […]

    Read More
  • November 4, 2016 - Chris Michael

    Ecore_Wl2: An EFL Library for Wayland Applications

    Throughout the years of developing Wayland support for EFL, few EFL libraries have had as much impact on EFL Wayland applications as the Ecore_Wayland library has. This library was one of the first to make it possible to truly run EFL applications in a Wayland environment. As the years progressed, it became apparent that Ecore_Wayland had some shortcomings; this blog post will introduce you to the replacement for Ecore_Wayland, called Ecore_Wl2. Ecore_Wayland’s Shortcomings While testing our first Wayland implementation, it became apparent that the initial implementation of the Ecore_Wayland library had some drawbacks. Publicly exposed structures could not be changed easily without breaking existing applications, and any changes to existing Wayland protocols would require significant changes to our Ecore_Wayland library. It was also discovered that when an EFL Wayland application creates a new window, the backend library also creates an entirely new display and connection to the Wayland server. This […]

    Read More
  • November 3, 2016 - Bryce Harrington

    Compose Key Support in Weston

    I recently added support to Weston for compose sequences via the configured compose key. This is now available in all of the Weston clients. What are “compose sequences”? Let’s say I need to write to someone named Zoë, but I don’t have an “ë” key on my keyboard. I can create the letter using separate key strokes:

    The first key, RAlt (the Alt key on the right side of the keyboard), is the compose key (also called the Multi-key). It signals that a compose sequence is beginning. The next key is double-quote, constructed by holding one of the Shift keys while pressing the single-quote key. Third we type the letter e. This completes the sequence. Or, more correctly, the system finds a match for this sequence in a table of available sequences, and thus considers it finished. The entry in the table indicates that the ‘ë’ symbol should be […]

    Read More
  • October 27, 2016 - Bryce Harrington

    The Basics of Input Methods in Weston

    Wayland provides an optional protocol, zwp_input_method, for defining alternate ways of sending keystrokes and mouse activity to clients. This could be things such as an onscreen keyboard or a popup for building Korean characters. The design of the protocol allows for different kinds of input methods to be made available via modular plugins, allowing them to be coded as discrete client applications, separate from the compositor’s core. The Wayland project maintains a reference compositor named Weston that provides implementations of the various protocols for demonstrative purposes, including two implementations of the zwp_input_method protocol. One input method, weston-keyboard, manages an on-screen keyboard that pops up at the bottom of the screen, similar to on-screen keyboards typically seen on touch-based mobile devices. The other input method, weston-simple-im, enables a compose key functionality. The user can configure which input method to use via their weston.ini file. No more than one input method can […]

    Read More
  • October 26, 2016 - Chris Michael

    Ecore_Drm2: How to Use Atomic Modesetting

    In a previous article, I briefly discussed how the Ecore_Drm2 library came into being. This article will expand on that article and provide a brief introduction to the Atomic Modesetting and Nuclear Pageflip features inside the new Ecore_Drm2 library. What Makes Atomic Modesetting and Nuclear Pageflip so Great? For those that are unaware of what “modesetting” is, you may read more about it here. Atomic Modesetting is a feature that allows for output modes (resolutions, refresh rate, etc) to be tested in advance on a single screen or on multiple outputs. A benefit of this feature is that the given mode may be tested prior to being applied. If the test of a given output mode fails, the screen image doesn’t need to be changed to confirm a given mode works or not, thus reducing screen flickering. Atomic/Nuclear Pageflipping allows for a given scanout framebuffer object and/or one or more hardware […]

    Read More
  • October 7, 2016 - Chris Michael

    Introducing the New & Improved Ecore_Drm2 Library

    In the early days of developing Wayland support in EFL/Enlightenment, it was quickly apparent that EFL would need an abstraction library to interface with libdrm. We wanted users of EFL to be able to call simple functions without having to know about the underlying internals of libdrm, thus the original Ecore_Drm library was born. First, efforts to develop this library were undertaken with much enthusiasm and little fan-fare. After the birth of Ecore_Drm, we then proceeded to integrate it’s usage into some new Evas and Ecore_Evas engines so that the Enlightenment Desktop Shell could make use of it and render our first standalone Wayland desktop implementation. After kicking the tires of our Wayland desktop for a while, we came to realize some shortcomings of the existing Ecore_Drm implementation. For starters, it would create it’s own Ecore_Drm_Device structure when launching the Enlightenment Wayland desktop (this structure was a representation of the […]

    Read More
  • September 20, 2016 - Bryce Harrington

    What’s New in Wayland and Weston 1.12?

    The 1.12 release of the Wayland core protocol and its reference compositor Weston will be later today; this post will give an overview of the major changes since the last release. New Features and Improvements to Wayland The Wayland core protocol documentation has received numerous refinements to improve its clarity and consistency. Along with this, many blank areas of the protocol documentation have been fleshed out. A new wl_display_add_protocol logger API provides a new, interactive way to debug requests; along with this are new APIs for examining clients and their resources. This is analogous to using WAYLAND_DEBUG=1, but more powerful since it allows run time review of log data such as through a UI view. There have been improvements to how the protocol XML scanner handles version identification in protocol headers. This enables better detection and fallback handling when compositors and clients support differt versions of their protocols. New Features […]

    Read More
  • September 6, 2016 - Reynaldo Verdejo

    Wayland Uninstalled, the Easy Way

    I recently had to start looking at some GStreamer & Wayland integration issues and, as everyone would, commenced by trying to setup a Wayland development environment. Before getting my feet wet though, I decided to have a chat about this with Derek Foreman: our resident Wayland expert. This isn’t surprising because on our team, pretty much every task starts by having a conversation (virtual or not) with one of the field specialists in the group. The idea is to save time, as you might have guessed. This time around I was looking for a fairly trivial piece of info: Me – “Hey Derek, I have Wayland installed on my distro for some reason – I don’t really want to take a look at now – and I would like to setup an upstream (development) Wayland environment without messing it up. Do you have some script like GStreamer’s gst-uninstalled so I can perform […]

    Read More