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 = std::move(callback);
  s_cleanup = std::move(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 = CheckError(SDL_GetClipboardMimeTypes(&count));
  if (!data) return {};
  return OwnArray<char*>{data, count};
}

 
} // namespace SDL
 
#endif /* SDL3PP_CLIPBOARD_H_ */