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	handle_update (const SDL_ClipboardEvent &ev)

Detailed Description

object that handles clipboard context for the SDL3 client

Definition at line 88 of file sdl_clip.hpp.

Constructor & Destructor Documentation

sdlClip()

sdlClip::sdlClip ( SdlContext *  sdl )

explicit

Definition at line 131 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();
}

~sdlClip()

sdlClip::~sdlClip ( )

virtual

Definition at line 143 of file sdl_clip.cpp.

{
  cliprdr_file_context_free(_file);
  ClipboardDestroy(_system);
  (void)CloseHandle(_event);
}

Member Function Documentation

handle_update()

bool sdlClip::handle_update

(

const SDL_ClipboardEvent &

ev

)

Definition at line 186 of file sdl_clip.cpp.

{
  if (!_ctx || !_sync || ev.owner)
  {
    _last_timestamp = ev.timestamp;
    if (!_current_mimetypes.empty())
    {
      _cache_data.clear();
      auto rc =
          SDL_SetClipboardData(sdlClip::ClipDataCb, sdlClip::ClipCleanCb, this, ev.mime_types,
                               WINPR_ASSERTING_INT_CAST(size_t, ev.num_mime_types));
      _current_mimetypes.clear();
      return rc;
    }
    return true;
  }
 
  if (ev.timestamp == _last_timestamp)
  {
    return true;
  }
 
  if (contains(ev.mime_types, ev.num_mime_types))
  {
    return true;
  }
 
  clearServerFormats();
 
  std::string mime_html = s_mime_html;
 
  std::vector<std::string> mime_bitmap = { BMP_MIME_LIST };
  std::string mime_webp = s_mime_webp;
  std::string mime_png = s_mime_png;
  std::string mime_jpeg = s_mime_jpg;
  std::string mime_tiff = s_mime_tiff;
  std::vector<std::string> mime_images = { mime_webp, mime_png, mime_jpeg, mime_tiff };
 
  std::vector<std::string> clientFormatNames;
  std::vector<CLIPRDR_FORMAT> clientFormats;
 
  size_t nformats = WINPR_ASSERTING_INT_CAST(size_t, ev.num_mime_types);
  const char** clipboard_mime_formats = ev.mime_types;
 
  WLog_Print(_log, WLOG_TRACE, "SDL has %d formats", nformats);
 
  bool textPushed = false;
  bool imgPushed = 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
 
        for (auto& bmp : mime_bitmap)
          clientFormatNames.push_back(bmp);
 
        for (auto& img : mime_images)
          clientFormatNames.push_back(img);
 
        clientFormatNames.emplace_back(s_type_HtmlFormat);
        imgPushed = true;
      }
    }
  }
 
  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);
  }
 
  WINPR_ASSERT(_ctx);
  WINPR_ASSERT(_ctx->ClientFormatList);
  return _ctx->ClientFormatList(_ctx, &formatList) == CHANNEL_RC_OK;
}

init()

BOOL sdlClip::init

(

CliprdrClientContext *

clip

)

Definition at line 150 of file sdl_clip.cpp.

{
  WINPR_ASSERT(clip);
  _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;
 
  return cliprdr_file_context_init(_file, _ctx);
}

uninit()

BOOL sdlClip::uninit

(

CliprdrClientContext *

clip

)

Definition at line 165 of file sdl_clip.cpp.

{
  WINPR_ASSERT(clip);
  if (!cliprdr_file_context_uninit(_file, _ctx))
    return FALSE;
  _ctx = nullptr;
  clip->custom = nullptr;
  return TRUE;
}

---

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

• sdl_clip.hpp
• sdl_clip.cpp