shm2.cpp

// Build with: g++ shm2.cpp -std=c++11 `pkg-config --cflags --libs wayland-client++ wayland-client-extra++ wayland-cursor++` -lrt -o shm2
 
#include <stdexcept>
#include <iostream>
#include <array>
#include <memory>
#include <sstream>
#include <ctime>
#include <algorithm>
#include <chrono>
 
#include <wayland-client.hpp>
#include <wayland-client-protocol-extra.hpp>
#include <linux/input.h>
#include <wayland-cursor.hpp>
 
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
 
using namespace wayland;
 
// example Wayland client
class example
{
private:
  // global objects
  display_t display;
  registry_t registry;
  compositor_t compositor;
  shell_t shell;
  xdg_wm_base_t xdg_wm_base;
  seat_t seat;
  shm_t shm;
  
  // local objects
  surface_t surface;
  shell_surface_t shell_surface;
  xdg_surface_t xdg_surface;
  xdg_toplevel_t xdg_toplevel;
  pointer_t pointer;
  keyboard_t keyboard;
  callback_t frame_cb;
  cursor_image_t cursor_image;
  buffer_t cursor_buffer;
  surface_t cursor_surface;
 
  // shared memory
  std::string name;
  int fd = 0;
  void *mem = nullptr;
  buffer_t buffer[2];
  int cur_buf;
 
  bool running;
  bool has_pointer;
  bool has_keyboard;
 
  unsigned int count;
  std::chrono::time_point<std::chrono::steady_clock> tstart;
 
  void draw(uint32_t serial = 0)
  {
    if(serial == 0)
      {
        std::fill_n(static_cast<uint32_t*>(mem)+cur_buf*320*240, 320*240, 0xffffff);
        surface.attach(buffer[cur_buf], 0, 0);
        surface.damage(0, 0, 320, 240);
        if(!cur_buf)
          cur_buf = 1;
        else
          cur_buf = 0;
        tstart = std::chrono::steady_clock::now();
        count = 0;
      }
 
    // schedule next draw
    frame_cb = surface.frame();
    frame_cb.on_done() = [this] (uint32_t serial) { this->draw(serial); };
    surface.commit();
 
    // measure fps
    auto now = std::chrono::steady_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(now - tstart).count();
    if(diff >= 1000)
      {
        std::cout << count << std::endl;
        tstart = now;
        count = 0;
      }
    count++;
  }
 
public:
  example()
  {
    // retrieve global objects
    registry = display.get_registry();
    registry.on_global() = [&] (uint32_t name, std::string interface, uint32_t version)
      {
        if(interface == compositor_t::interface_name)
          registry.bind(name, compositor, version);
        else if(interface == shell_t::interface_name)
          registry.bind(name, shell, version);
        else if(interface == xdg_wm_base_t::interface_name)
          registry.bind(name, xdg_wm_base, version);
        else if(interface == seat_t::interface_name)
          registry.bind(name, seat, version);
        else if(interface == shm_t::interface_name)
          registry.bind(name, shm, version);
      };
    display.roundtrip();
 
    seat.on_capabilities() = [&] (seat_capability capability)
      {
        has_keyboard = capability & seat_capability::keyboard;
        has_pointer = capability & seat_capability::pointer;
      };
 
    // create a surface
    surface = compositor.create_surface();
 
    // create a shell surface
    if(xdg_wm_base)
      {
        xdg_wm_base.on_ping() = [&] (uint32_t serial) { xdg_wm_base.pong(serial); };
        xdg_surface = xdg_wm_base.get_xdg_surface(surface);
        xdg_surface.on_configure() = [&] (uint32_t serial) { xdg_surface.ack_configure(serial); };
        xdg_toplevel = xdg_surface.get_toplevel();
        xdg_toplevel.set_title("Window");
        xdg_toplevel.on_close() = [&] () { running = false; };
      }
    else
      {
        shell_surface = shell.get_shell_surface(surface);
        shell_surface.on_ping() = [&] (uint32_t serial) { shell_surface.pong(serial); };
        shell_surface.set_title("Window");
        shell_surface.set_toplevel();
      }
    surface.commit();
 
    display.roundtrip();
 
    // Get input devices
    if(!has_keyboard)
      throw std::runtime_error("No keyboard found.");
    if(!has_pointer)
      throw std::runtime_error("No pointer found.");
 
    pointer = seat.get_pointer();
    keyboard = seat.get_keyboard();
 
    // create random filename
    std::stringstream ss;
    std::srand(std::time(0));
    ss << '/' << std::rand();
    name = ss.str();
 
    // open shared memory file
    fd = shm_open(name.c_str(), O_RDWR | O_CREAT | O_EXCL, 0600);
    if(fd < 0)
      throw std::runtime_error("shm_open failed.");
 
    // set size
    if(ftruncate(fd, 2*320*240*4) < 0)
      throw std::runtime_error("ftruncate failed.");
 
    // map memory
    mem = mmap(NULL, 2*320*240*4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(mem == MAP_FAILED)
      throw std::runtime_error("mmap failed.");
 
    // create shared memory
    auto pool = shm.create_pool(fd, 2*320*240*4);
    for(unsigned int c = 0; c < 2; c++)
      buffer[c] = pool.create_buffer(c*320*240*4, 320, 240, 320*4, shm_format::argb8888);
    cur_buf = 0;
 
    // load cursor theme
    cursor_theme_t cursor_theme = cursor_theme_t("default", 16, shm);
    cursor_t cursor = cursor_theme.get_cursor("cross");
    cursor_image = cursor.image(0);
    cursor_buffer = cursor_image.get_buffer();
 
    // create cursor surface
    cursor_surface = compositor.create_surface();
 
    // draw cursor
    pointer.on_enter() = [&] (uint32_t serial, surface_t, int32_t, int32_t)
      {
        cursor_surface.attach(cursor_buffer, 0, 0);
        cursor_surface.damage(0, 0, cursor_image.width(), cursor_image.height());
        cursor_surface.commit();
        pointer.set_cursor(serial, cursor_surface, 0, 0);
      };
    
    // window movement
    pointer.on_button() = [&] (uint32_t serial, uint32_t time, uint32_t button, pointer_button_state state)
      {
        if(button == BTN_LEFT && state == pointer_button_state::pressed)
          {
            if(xdg_toplevel)
              xdg_toplevel.move(seat, serial);
            else
              shell_surface.move(seat, serial);
          }
      };
 
    // press 'q' to exit
    keyboard.on_key() = [&] (uint32_t, uint32_t, uint32_t key, keyboard_key_state state)
      {
        if(key == KEY_Q && state == keyboard_key_state::pressed)
          running = false;
      };
 
    // draw stuff
    draw();
  }
 
  ~example()
  {
    // close shared memory
    munmap(mem, 2*320*240*4);
    close(fd);
    shm_unlink(name.c_str());
  }
 
  void run()
  {
    // event loop
    running = true;
    while(running)
      display.dispatch();
  }
};
 
int main()
{
  example e;
  e.run();
  return 0;
}