SDL3pp_clipboard.h

#ifndef SDL3PP_CLIPBOARD_H_
#define SDL3PP_CLIPBOARD_H_
 
#include <SDL3/SDL_clipboard.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
inline void SetClipboardText(StringParam text)
{
  CheckError(SDL_SetClipboardText(text));
}
 
inline StringResult GetClipboardText()
{
  return StringResult{CheckError(SDL_GetClipboardText())};
}
 
inline bool HasClipboardText() { return SDL_HasClipboardText(); }
 
inline void SetPrimarySelectionText(StringParam text)
{
  CheckError(SDL_SetPrimarySelectionText(text));
}
 
inline StringResult GetPrimarySelectionText()
{
  return StringResult{CheckError(SDL_GetPrimarySelectionText())};
}
 
inline bool HasPrimarySelectionText() { return SDL_HasPrimarySelectionText(); }
 
using ClipboardDataCallback = const void*(SDLCALL*)(void* userdata,
                                                    const char* mime_type,
                                                    size_t* size);
 
using ClipboardDataCB = std::function<SourceBytes(const char* mime_type)>;
 
using ClipboardCleanupCallback = void(SDLCALL*)(void* userdata);
 
using ClipboardCleanupCB = std::function<void()>;
 
inline void SetClipboardData(ClipboardDataCallback callback,
                             ClipboardCleanupCallback cleanup,
                             void* userdata,
                             std::span<const char*> mime_types)
{
  CheckError(SDL_SetClipboardData(
    callback, cleanup, userdata, mime_types.data(), mime_types.size()));
}
 
inline void SetClipboardData(ClipboardDataCB callback,
                             ClipboardCleanupCB cleanup,
                             std::span<const char*> mime_types)
{
  static ClipboardDataCB s_callback;
  static ClipboardCleanupCB s_cleanup;
  CheckError(SDL_ClearClipboardData());
  s_callback = callback;
  s_cleanup = cleanup;
  SetClipboardData(
    [](void*, const char* mime_type, size_t* size) -> const void* {
      auto source = s_callback(mime_type);
      *size = source.size_bytes();
      return source.data();
    },
    [](void*) {
      if (s_cleanup) s_cleanup();
    },
    nullptr,
    mime_types);
}
 
inline void ClearClipboardData() { CheckError(SDL_ClearClipboardData()); }
 
inline StringResult GetClipboardData(StringParam mime_type)
{
  size_t count = 0;
  auto data = SDL_GetClipboardData(mime_type, &count);
  if (!data) return {};
  return StringResult{static_cast<char*>(data), count};
}
 
template<class T>
inline OwnArray<T> GetClipboardDataAs(StringParam mime_type)
{
  size_t count = 0;
  auto data = SDL_GetClipboardData(mime_type, &count);
  if (!data) return {};
  return OwnArray<T>{static_cast<T*>(data), count / sizeof(T)};
}
 
inline bool HasClipboardData(StringParam mime_type)
{
  return SDL_HasClipboardData(mime_type);
}
 
inline OwnArray<char*> GetClipboardMimeTypes()
{
  size_t count = 0;
  auto data = SDL_GetClipboardMimeTypes(&count);
  if (!data) return {};
  return OwnArray<char*>{data, count};
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_CLIPBOARD_H_ */