xbmc/windowing/wayland/Seat.cpp

   1 /*
   2  *  Copyright (C) 2017-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "Seat.h"
  10
  11 #include "utils/log.h"
  12
  13 #include "platform/posix/utils/FileHandle.h"
  14 #include "platform/posix/utils/Mmap.h"
  15
  16 #include <cassert>
  17 #include <utility>
  18
  19 #include <unistd.h>
  20
  21 using namespace KODI::WINDOWING::WAYLAND;
  22 using namespace std::placeholders;
  23
  24 namespace
  25 {
  26
  27 /**
  28  * Handle change of availability of a wl_seat input capability
  29  *
  30  * This checks whether the capability is currently available with the wl_seat
  31  * and whether it was bound to a protocol object. If there is a mismatch between
  32  * these two, the protocol proxy is released if a capability was removed or bound
  33  * if a capability was added.
  34  *
  35  * \param caps new capabilities
  36  * \param cap capability to check for
  37  * \param seatName human-readable name of the seat for log messages
  38  * \param capName human-readable name of the capability for log messages
  39  * \param proxy proxy object that should be filled with a new instance or reset
  40  * \param instanceProvider function that functions as factory for the Wayland
  41  *                         protocol instance if the capability has been added
  42  */
  43 template<typename T, typename InstanceProviderT>
  44 bool HandleCapabilityChange(const wayland::seat_capability& caps,
  45                             const wayland::seat_capability& cap,
  46                             std::string const& seatName,
  47                             std::string const& capName,
  48                             T& proxy,
  49                             InstanceProviderT instanceProvider)
  50 {
  51   bool hasCapability = caps & cap;
  52
  53   if ((!!proxy) != hasCapability)
  54   {
  55     // Capability changed
  56
  57     if (hasCapability)
  58     {
  59       // The capability was added
  60       CLog::Log(LOGDEBUG, "Wayland seat {} gained capability {}", seatName, capName);
  61       proxy = instanceProvider();
  62       return true;
  63     }
  64     else
  65     {
  66       // The capability was removed
  67       CLog::Log(LOGDEBUG, "Wayland seat {} lost capability {}", seatName, capName);
  68       proxy.proxy_release();
  69     }
  70   }
  71
  72   return false;
  73 }
  74
  75 }
  76
  77 CSeat::CSeat(std::uint32_t globalName, wayland::seat_t const& seat, CConnection& connection)
  78 : m_globalName{globalName}, m_seat{seat}, m_selection{connection, seat}
  79 {
  80   m_seat.on_name() = [this](std::string name) { m_name = std::move(name); };
  81   m_seat.on_capabilities() = std::bind(&CSeat::HandleOnCapabilities, this, std::placeholders::_1);
  82 }
  83
  84 CSeat::~CSeat() noexcept = default;
  85
  86 void CSeat::AddRawInputHandlerKeyboard(KODI::WINDOWING::WAYLAND::IRawInputHandlerKeyboard *rawKeyboardHandler)
  87 {
  88   assert(rawKeyboardHandler);
  89   m_rawKeyboardHandlers.emplace(rawKeyboardHandler);
  90 }
  91
  92 void CSeat::RemoveRawInputHandlerKeyboard(KODI::WINDOWING::WAYLAND::IRawInputHandlerKeyboard *rawKeyboardHandler)
  93 {
  94   m_rawKeyboardHandlers.erase(rawKeyboardHandler);
  95 }
  96
  97 void CSeat::AddRawInputHandlerPointer(IRawInputHandlerPointer* rawPointerHandler)
  98 {
  99   assert(rawPointerHandler);
 100   m_rawPointerHandlers.emplace(rawPointerHandler);
 101 }
 102
 103 void CSeat::RemoveRawInputHandlerPointer(KODI::WINDOWING::WAYLAND::IRawInputHandlerPointer *rawPointerHandler)
 104 {
 105   m_rawPointerHandlers.erase(rawPointerHandler);
 106 }
 107
 108 void CSeat::AddRawInputHandlerTouch(IRawInputHandlerTouch* rawTouchHandler)
 109 {
 110   assert(rawTouchHandler);
 111   m_rawTouchHandlers.emplace(rawTouchHandler);
 112 }
 113
 114 void CSeat::RemoveRawInputHandlerTouch(KODI::WINDOWING::WAYLAND::IRawInputHandlerTouch *rawTouchHandler)
 115 {
 116   m_rawTouchHandlers.erase(rawTouchHandler);
 117 }
 118
 119 void CSeat::HandleOnCapabilities(const wayland::seat_capability& caps)
 120 {
 121   if (HandleCapabilityChange(caps, wayland::seat_capability::keyboard, GetName(), "keyboard", m_keyboard, std::bind(&wayland::seat_t::get_keyboard, m_seat)))
 122   {
 123     HandleKeyboardCapability();
 124   }
 125   if (HandleCapabilityChange(caps, wayland::seat_capability::pointer, GetName(), "pointer", m_pointer, std::bind(&wayland::seat_t::get_pointer, m_seat)))
 126   {
 127     HandlePointerCapability();
 128   }
 129   if (HandleCapabilityChange(caps, wayland::seat_capability::touch, GetName(), "touch", m_touch, std::bind(&wayland::seat_t::get_touch, m_seat)))
 130   {
 131     HandleTouchCapability();
 132   }
 133 }
 134
 135 void CSeat::SetCursor(std::uint32_t serial, wayland::surface_t const &surface, std::int32_t hotspotX, std::int32_t hotspotY)
 136 {
 137   if (m_pointer)
 138   {
 139     m_pointer.set_cursor(serial, surface, hotspotX, hotspotY);
 140   }
 141 }
 142
 143 void CSeat::HandleKeyboardCapability()
 144 {
 145   m_keyboard.on_keymap() = [this](wayland::keyboard_keymap_format format, int fd, std::uint32_t size)
 146   {
 147     KODI::UTILS::POSIX::CFileHandle fdGuard{fd};
 148     KODI::UTILS::POSIX::CMmap mmap{nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0};
 149     std::string keymap{static_cast<const char*> (mmap.Data()), size};
 150     for (auto handler : m_rawKeyboardHandlers)
 151     {
 152       handler->OnKeyboardKeymap(this, format, keymap);
 153     }
 154   };
 155   m_keyboard.on_enter() = [this](std::uint32_t serial, const wayland::surface_t& surface,
 156                                  const wayland::array_t& keys) {
 157     for (auto handler : m_rawKeyboardHandlers)
 158     {
 159       handler->OnKeyboardEnter(this, serial, surface, keys);
 160     }
 161   };
 162   m_keyboard.on_leave() = [this](std::uint32_t serial, const wayland::surface_t& surface) {
 163     for (auto handler : m_rawKeyboardHandlers)
 164     {
 165       handler->OnKeyboardLeave(this, serial, surface);
 166     }
 167   };
 168   m_keyboard.on_key() = [this](std::uint32_t serial, std::uint32_t time, std::uint32_t key, wayland::keyboard_key_state state)
 169   {
 170     for (auto handler : m_rawKeyboardHandlers)
 171     {
 172       handler->OnKeyboardKey(this, serial, time, key, state);
 173     }
 174   };
 175   m_keyboard.on_modifiers() = [this](std::uint32_t serial, std::uint32_t modsDepressed, std::uint32_t modsLatched, std::uint32_t modsLocked, std::uint32_t group)
 176   {
 177     for (auto handler : m_rawKeyboardHandlers)
 178     {
 179       handler->OnKeyboardModifiers(this, serial, modsDepressed, modsLatched, modsLocked, group);
 180     }
 181   };
 182   InstallKeyboardRepeatInfo();
 183 }
 184
 185 void CSeat::InstallKeyboardRepeatInfo()
 186 {
 187   m_keyboard.on_repeat_info() = [this](std::int32_t rate, std::int32_t delay)
 188   {
 189     for (auto handler : m_rawKeyboardHandlers)
 190     {
 191       handler->OnKeyboardRepeatInfo(this, rate, delay);
 192     }
 193   };
 194 }
 195
 196 void CSeat::HandlePointerCapability()
 197 {
 198   m_pointer.on_enter() = [this](std::uint32_t serial, const wayland::surface_t& surface,
 199                                 double surfaceX, double surfaceY) {
 200     for (auto handler : m_rawPointerHandlers)
 201     {
 202       handler->OnPointerEnter(this, serial, surface, surfaceX, surfaceY);
 203     }
 204   };
 205   m_pointer.on_leave() = [this](std::uint32_t serial, const wayland::surface_t& surface) {
 206     for (auto handler : m_rawPointerHandlers)
 207     {
 208       handler->OnPointerLeave(this, serial, surface);
 209     }
 210   };
 211   m_pointer.on_motion() = [this](std::uint32_t time, double surfaceX, double surfaceY)
 212   {
 213     for (auto handler : m_rawPointerHandlers)
 214     {
 215       handler->OnPointerMotion(this, time, surfaceX, surfaceY);
 216     }
 217   };
 218   m_pointer.on_button() = [this](std::uint32_t serial, std::uint32_t time, std::uint32_t button, wayland::pointer_button_state state)
 219   {
 220     for (auto handler : m_rawPointerHandlers)
 221     {
 222       handler->OnPointerButton(this, serial, time, button, state);
 223     }
 224   };
 225   m_pointer.on_axis() = [this](std::uint32_t time, wayland::pointer_axis axis, double value)
 226   {
 227     for (auto handler : m_rawPointerHandlers)
 228     {
 229       handler->OnPointerAxis(this, time, axis, value);
 230     }
 231   };
 232   // Wayland groups pointer events, but right now there is no benefit in
 233   // treating them in groups. The main use case for doing so seems to be
 234   // multi-axis (i.e. diagonal) scrolling, but we do not support this anyway.
 235   /*m_pointer.on_frame() = [this]()
 236   {
 237
 238   };*/
 239 }
 240
 241 void CSeat::HandleTouchCapability()
 242 {
 243   m_touch.on_down() = [this](std::uint32_t serial, std::uint32_t time,
 244                              const wayland::surface_t& surface, std::int32_t id, double x,
 245                              double y) {
 246     for (auto handler : m_rawTouchHandlers)
 247     {
 248       handler->OnTouchDown(this, serial, time, surface, id, x, y);
 249     }
 250   };
 251   m_touch.on_up() = [this](std::uint32_t serial, std::uint32_t time, std::int32_t id)
 252   {
 253     for (auto handler : m_rawTouchHandlers)
 254     {
 255       handler->OnTouchUp(this, serial, time, id);
 256     }
 257   };
 258   m_touch.on_motion() = [this](std::uint32_t time, std::int32_t id, double x, double y)
 259   {
 260     for (auto handler : m_rawTouchHandlers)
 261     {
 262       handler->OnTouchMotion(this, time, id, x, y);
 263     }
 264   };
 265   m_touch.on_cancel() = [this]()
 266   {
 267     for (auto handler : m_rawTouchHandlers)
 268     {
 269       handler->OnTouchCancel(this);
 270     }
 271   };
 272   m_touch.on_shape() = [this](std::int32_t id, double major, double minor)
 273   {
 274     for (auto handler : m_rawTouchHandlers)
 275     {
 276       handler->OnTouchShape(this, id, major, minor);
 277     }
 278   };
 279 }