sdlClip Class Reference

object that handles clipboard context for the SDL3 client More...

#include <sdl_clip.hpp>

Public Member Functions
	sdlClip (SdlContext *sdl)
	sdlClip (const sdlClip &)=delete
	sdlClip (sdlClip &&)=delete
sdlClip &	operator= (const sdlClip &)=delete
sdlClip &	operator= (sdlClip &&)=delete
bool	init (CliprdrClientContext *clip)
bool	uninit (CliprdrClientContext *clip)
bool	handleEvent (const SDL_ClipboardEvent &ev)
void	handleDataRequests ()

Detailed Description

object that handles clipboard context for the SDL3 client

Definition at line 76 of file sdl_clip.hpp.

Constructor & Destructor Documentation

sdlClip()

sdlClip::sdlClip ( SdlContext *  sdl )

explicit

Definition at line 226 of file sdl_clip.cpp.

    : _sdl(sdl), _file(cliprdr_file_context_new(this)), _log(WLog_Get(TAG)),
      _system(ClipboardCreate()), _event(CreateEventA(nullptr, TRUE, FALSE, nullptr)),
      _uuid(sdl::utils::generate_uuid_v4())
{
  WINPR_ASSERT(sdl);
 
  std::stringstream ss;
  ss << s_mime_freerdp_update << "-" << _uuid;
  _mime_uuid = ss.str();
 
  std::ignore = cliprdr_file_context_set_locally_available(_file, TRUE);
}

~sdlClip()

sdlClip::~sdlClip ( )

virtual

Definition at line 240 of file sdl_clip.cpp.

{
#if defined(__EMSCRIPTEN__)
  {
    std::scoped_lock web(s_web_lock);
    if (s_web_clip == this)
      s_web_clip = nullptr;
  }
#endif
  cliprdr_file_context_free(_file);
  ClipboardDestroy(_system);
  std::ignore = CloseHandle(_event);
}

Member Function Documentation

handleDataRequests()

void sdlClip::handleDataRequests

(

)

Definition at line 1085 of file sdl_clip.cpp.

{
  for (;;)
  {
    uint32_t formatId = 0;
    {
      std::scoped_lock lock(_lock);
      if (_server_requests.empty())
        return;
      formatId = _server_requests.front();
      _server_requests.pop_front();
      if (!_ctx)
        continue;
    }
 
    uint32_t len = 0;
    auto data = getLocalData(formatId, len);
    std::scoped_lock lock(_lock);
    if (!_ctx)
      continue;
    if (SendDataResponse(data.get(), len) != CHANNEL_RC_OK)
      WLog_Print(_log, WLOG_WARN, "failed to send clipboard data response");
  }
}

handleEvent()

bool sdlClip::handleEvent

(

const SDL_ClipboardEvent &

ev

)

Definition at line 313 of file sdl_clip.cpp.

{
  std::unique_ptr<char*, decltype(&SDL_free)> current(nullptr, SDL_free);
  const char** mime_types = ev.mime_types;
  size_t nformats = WINPR_ASSERTING_INT_CAST(size_t, ev.num_mime_types);
  bool connected = false;
  {
    std::scoped_lock lock(_lock);
    connected = (_ctx != nullptr);
  }
  if (connected && _ctx && _sync && ev.owner && (ev.num_mime_types == 1))
  {
    if (strcmp(first_announcement[0], ev.mime_types[0]) == 0)
    {
      current.reset(SDL_GetClipboardMimeTypes(&nformats));
      mime_types = const_cast<const char**>(current.get());
      if (!mime_types)
        nformats = 0;
    }
  }
  else if (!connected || !_ctx || !_sync || ev.owner)
  {
    _last_timestamp = ev.timestamp;
 
    /* The channel thread replaces _current_mimetypes on every server format list, so take
     * them under the lock instead of trusting pointers carried in the event. */
    std::vector<std::string> mimes;
    {
      ClipboardLockGuard systemlock(_system);
      std::scoped_lock lock(_lock);
      mimes.swap(_current_mimetypes);
      if (!mimes.empty())
        _cache_data.clear();
    }
    if (mimes.empty())
      return true;
 
    std::vector<const char*> cmimes;
    cmimes.reserve(mimes.size());
    for (const auto& m : mimes)
      cmimes.push_back(m.c_str());
 
    /* Server files need native clipboard items on some platforms (macOS), which only the
     * file context can offer. It requests the data with ClipDataCb like SDL does. */
    if (cliprdr_file_context_set_local_clipboard_data(_file, sdlClip::ClipDataCb, this,
                                                      cmimes.data(), cmimes.size()))
      return true;
 
    /* SDL copies the mime type strings */
    return SDL_SetClipboardData(sdlClip::ClipDataCb, sdlClip::ClipCleanCb, this, cmimes.data(),
                                cmimes.size());
  }
 
  if (ev.timestamp == _last_timestamp)
    return true;
 
  if (contains(mime_types, WINPR_ASSERTING_INT_CAST(Sint32, nformats)))
    return true;
 
  /* SDL holds this session's server data right now, so this update was queued before our
   * later SDL_SetClipboardData took effect: typically the selection a compositor re-sends on
   * focus-in, racing a server format list. Announcing it would replace the fresh server
   * clipboard with the stale local one (and the server would then ask us for data we no
   * longer own). A genuine local change cancels our data before its update is queued. */
  if (ownsClipboard())
  {
    WLog_Print(_log, WLOG_DEBUG, "ignoring stale local clipboard update");
    return true;
  }
 
  {
    ClipboardLockGuard systemlock(_system);
    std::scoped_lock lock(_lock);
    clearServerFormats();
  }
 
  const std::string mime_html = s_mime_html;
 
  const std::vector<std::string> mime_bitmap = { BMP_MIME_LIST };
  const std::string mime_webp = s_mime_webp;
  const std::string mime_png = s_mime_png;
  const std::string mime_jpeg = s_mime_jpg;
  const std::string mime_tiff = s_mime_tiff;
  const std::vector<std::string> mime_images = { mime_webp, mime_png,    mime_jpeg,
                                               mime_tiff, s_mime_avif, s_mime_jxl };
 
  std::vector<std::string> clientFormatNames;
  std::vector<CLIPRDR_FORMAT> clientFormats;
 
  const char** clipboard_mime_formats = mime_types;
 
  WLog_Print(_log, WLOG_TRACE, "SDL has %" PRIuz " formats", nformats);
 
  bool textPushed = false;
  bool imgPushed = false;
  bool filePushed = false;
 
  for (size_t i = 0; i < nformats; i++)
  {
    std::string local_mime = clipboard_mime_formats[i];
    WLog_Print(_log, WLOG_TRACE, " - %s", local_mime.c_str());
 
    if (std::find(s_mime_text().begin(), s_mime_text().end(), local_mime) !=
        s_mime_text().end())
    {
      /* text formats */
      if (!textPushed)
      {
        clientFormats.push_back({ CF_TEXT, nullptr });
        clientFormats.push_back({ CF_OEMTEXT, nullptr });
        clientFormats.push_back({ CF_UNICODETEXT, nullptr });
        textPushed = true;
      }
    }
    else if (local_mime == mime_html)
      /* html */
      clientFormatNames.emplace_back(s_type_HtmlFormat);
    else if ((std::find(mime_bitmap.begin(), mime_bitmap.end(), local_mime) !=
              mime_bitmap.end()) ||
             (std::find(mime_images.begin(), mime_images.end(), local_mime) !=
              mime_images.end()))
    {
      /* image formats */
      if (!imgPushed)
      {
        clientFormats.push_back({ CF_DIB, nullptr });
#if defined(WINPR_UTILS_IMAGE_DIBv5)
        clientFormats.push_back({ CF_DIBV5, nullptr });
#endif
 
        if (winpr_image_format_is_supported(WINPR_IMAGE_BITMAP))
        {
          for (auto& bmp : mime_bitmap)
            clientFormatNames.emplace_back(bmp);
        }
 
        if (winpr_image_format_is_supported(WINPR_IMAGE_JPEG))
          clientFormatNames.emplace_back(mime_jpeg);
        if (winpr_image_format_is_supported(WINPR_IMAGE_WEBP))
          clientFormatNames.emplace_back(mime_webp);
        if (winpr_image_format_is_supported(WINPR_IMAGE_PNG))
          clientFormatNames.emplace_back(mime_png);
 
        clientFormatNames.emplace_back(s_type_HtmlFormat);
        imgPushed = true;
      }
      clientFormatNames.emplace_back(local_mime);
    }
    else if (mime_is_file(local_mime) || (local_mime == s_type_file_url))
    {
      if (!filePushed)
      {
        clientFormatNames.emplace_back(s_type_FileGroupDescriptorW);
        filePushed = true;
      }
    }
  }
 
  std::sort(clientFormatNames.begin(), clientFormatNames.end());
  clientFormatNames.erase(std::unique(clientFormatNames.begin(), clientFormatNames.end()),
                          clientFormatNames.end());
 
  for (auto& name : clientFormatNames)
  {
    clientFormats.push_back({ ClipboardRegisterFormat(_system, name.c_str()), name.data() });
  }
 
  std::sort(clientFormats.begin(), clientFormats.end(),
            [](const auto& a, const auto& b) { return a < b; });
  auto u = std::unique(clientFormats.begin(), clientFormats.end());
  clientFormats.erase(u, clientFormats.end());
 
  const CLIPRDR_FORMAT_LIST formatList = {
    { CB_FORMAT_LIST, 0, 0 },
    static_cast<UINT32>(clientFormats.size()),
    clientFormats.data(),
  };
 
  WLog_Print(_log, WLOG_TRACE,
             "-------------- client format list [%" PRIu32 "] ------------------",
             formatList.numFormats);
  for (UINT32 x = 0; x < formatList.numFormats; x++)
  {
    auto format = &formatList.formats[x];
    WLog_Print(_log, WLOG_TRACE, "client announces %" PRIu32 " [%s][%s]", format->formatId,
               ClipboardGetFormatIdString(format->formatId), format->formatName);
  }
 
  /* The RDP thread may have closed the channel since the check above (see uninit) */
  ClipboardLockGuard systemlock(_system);
  std::scoped_lock lock(_lock);
  if (!_ctx)
    return true;
 
  if (cliprdr_file_context_notify_new_client_format_list(_file) != CHANNEL_RC_OK)
    return false;
 
  WINPR_ASSERT(_ctx);
  WINPR_ASSERT(_ctx->ClientFormatList);
  return _ctx->ClientFormatList(_ctx, &formatList) == CHANNEL_RC_OK;
}

init()

bool sdlClip::init

(

CliprdrClientContext *

clip

)

Definition at line 254 of file sdl_clip.cpp.

{
  WINPR_ASSERT(clip);
  ClipboardLockGuard systemlock(_system);
  std::scoped_lock lock(_lock);
  _ctx = clip;
  clip->custom = this;
  _ctx->MonitorReady = sdlClip::MonitorReady;
  _ctx->ServerCapabilities = sdlClip::ReceiveServerCapabilities;
  _ctx->ServerFormatList = sdlClip::ReceiveServerFormatList;
  _ctx->ServerFormatListResponse = sdlClip::ReceiveFormatListResponse;
  _ctx->ServerFormatDataRequest = sdlClip::ReceiveFormatDataRequest;
  _ctx->ServerFormatDataResponse = sdlClip::ReceiveFormatDataResponse;
#if defined(__EMSCRIPTEN__)
  {
    std::scoped_lock web(s_web_lock);
    s_web_clip = this;
  }
#endif
 
  return cliprdr_file_context_init(_file, _ctx);
}

uninit()

bool sdlClip::uninit

(

CliprdrClientContext *

clip

)

Definition at line 277 of file sdl_clip.cpp.

{
  WINPR_ASSERT(clip);
#if defined(__EMSCRIPTEN__)
  {
    std::scoped_lock web(s_web_lock);
    if (s_web_clip == this)
      s_web_clip = nullptr;
  }
#endif
  ClipboardLockGuard systemlock(_system);
  std::scoped_lock lock(_lock);
  if (!cliprdr_file_context_uninit(_file, _ctx))
    return false;
  _ctx = nullptr;
  clip->custom = nullptr;
  _server_requests.clear();
  return true;
}

---

The documentation for this class was generated from the following files:

• sdl_clip.hpp
• sdl_clip.cpp