SDL3pp_tray.h

#ifndef SDL3PP_TRAY_H_
#define SDL3PP_TRAY_H_
 
#include <SDL3/SDL_tray.h>
#include "SDL3pp_stdinc.h"
#include "SDL3pp_surface.h"
 
namespace SDL {
 
// Forward decl
struct TrayMenu;
 
// Forward decl
struct TrayBase;
 
// Forward decl
struct TrayRef;
 
// Forward decl
struct Tray;
 
// Forward decl
struct TrayEntryBase;
 
// Forward decl
struct TrayEntryRef;
 
// Forward decl
struct TrayEntry;
 
using DetachedTrayEntry = DetachedResource<TrayEntryRef, TrayEntry>;
 
using TrayEntryFlags = Uint32;
 
constexpr TrayEntryFlags TRAYENTRY_BUTTON =
  SDL_TRAYENTRY_BUTTON; 
 
constexpr TrayEntryFlags TRAYENTRY_CHECKBOX =
  SDL_TRAYENTRY_CHECKBOX; 
 
constexpr TrayEntryFlags TRAYENTRY_SUBMENU =
  SDL_TRAYENTRY_SUBMENU; 
 
constexpr TrayEntryFlags TRAYENTRY_DISABLED =
  SDL_TRAYENTRY_DISABLED; 
 
constexpr TrayEntryFlags TRAYENTRY_CHECKED = SDL_TRAYENTRY_CHECKED;
 
struct TrayBase : Resource<SDL_Tray*>
{
  using Resource::Resource;
 
  TrayBase(SurfaceBase& icon, StringParam tooltip)
    : Resource(CheckError(SDL_CreateTray(icon.get(), tooltip)))
  {
  }
 
  void SetIcon(SurfaceBase& icon) { SDL_SetTrayIcon(get(), icon.get()); }
 
  void SetTooltip(StringParam tooltip) { SDL_SetTrayTooltip(get(), tooltip); }
 
  TrayMenu CreateMenu();
 
  TrayMenu GetMenu() const;
};
 
struct TrayRef : TrayBase
{
  using TrayBase::TrayBase;
 
  constexpr TrayRef(const TrayRef& other)
    : TrayBase(other.get())
  {
  }
 
  constexpr TrayRef(TrayRef&& other)
    : TrayBase(other.release())
  {
  }
 
  constexpr ~TrayRef() = default;
 
  TrayRef& operator=(TrayRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Tray* newResource = {})
  {
    SDL_DestroyTray(release(newResource));
  }
};
 
struct Tray : TrayRef
{
  using TrayRef::TrayRef;
 
  constexpr explicit Tray(SDL_Tray* resource = {})
    : TrayRef(resource)
  {
  }
 
  constexpr Tray(const Tray& other) = delete;
 
  constexpr Tray(Tray&& other) = default;
 
  ~Tray() { reset(); }
 
  Tray& operator=(Tray other)
  {
    reset(other.release());
    return *this;
  }
};
 
using TrayCallback = SDL_TrayCallback;
 
using TrayCB = std::function<void(TrayEntryRef)>;
 
class TrayMenu
{
  SDL_TrayMenu* m_trayMenu;
 
public:
  constexpr TrayMenu(SDL_TrayMenu* trayMenu = {})
    : m_trayMenu(trayMenu)
  {
  }
 
  constexpr bool operator==(const TrayMenu& other) const = default;
 
  constexpr bool operator==(SDL_TrayMenu* trayMenu) const
  {
    return operator==(TrayMenu(trayMenu));
  }
 
  constexpr operator SDL_TrayMenu*() const { return m_trayMenu; }
 
  constexpr explicit operator bool() const { return m_trayMenu != nullptr; }
 
  std::span<TrayEntry> GetEntries();
 
  DetachedTrayEntry InsertEntry(int pos,
                                StringParam label,
                                TrayEntryFlags flags);
 
  DetachedTrayEntry AppendEntry(StringParam label, TrayEntryFlags flags);
 
  TrayEntryRef GetParentEntry() const;
 
  TrayRef GetParentTray() const;
};
 
struct TrayEntryBase : Resource<SDL_TrayEntry*>
{
  using Resource::Resource;
 
  TrayMenu CreateSubmenu() { return SDL_CreateTraySubmenu(get()); }
 
  TrayMenu GetSubmenu() { return SDL_GetTraySubmenu(get()); }
 
  void SetLabel(StringParam label) { SDL_SetTrayEntryLabel(get(), label); }
 
  const char* GetLabel() const { return SDL_GetTrayEntryLabel(get()); }
 
  void SetChecked(bool checked) { SDL_SetTrayEntryChecked(get(), checked); }
 
  bool GetChecked() const { return SDL_GetTrayEntryChecked(get()); }
 
  void SetEnabled(bool enabled) { SDL_SetTrayEntryEnabled(get(), enabled); }
 
  bool GetEnabled() const { return SDL_GetTrayEntryEnabled(get()); }
 
  void SetCallback(TrayCB callback);
 
  void SetCallback(TrayCallback callback, void* userdata)
  {
    SDL_SetTrayEntryCallback(get(), callback, userdata);
  }
 
  void Click() { SDL_ClickTrayEntry(get()); }
 
  TrayMenu GetParent() { return SDL_GetTrayEntryParent(get()); }
};
 
struct TrayEntryRef : TrayEntryBase
{
  using TrayEntryBase::TrayEntryBase;
 
  constexpr TrayEntryRef(const TrayEntryRef& other)
    : TrayEntryBase(other.get())
  {
  }
 
  constexpr TrayEntryRef(TrayEntryRef&& other)
    : TrayEntryBase(other.release())
  {
  }
 
  constexpr ~TrayEntryRef() = default;
 
  TrayEntryRef& operator=(TrayEntryRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_TrayEntry* newResource = {})
  {
    SDL_RemoveTrayEntry(release(newResource));
  }
 
  void Remove() { reset(); }
};
 
struct TrayEntry : TrayEntryRef
{
  using TrayEntryRef::TrayEntryRef;
 
  constexpr explicit TrayEntry(SDL_TrayEntry* resource = {})
    : TrayEntryRef(resource)
  {
  }
 
  constexpr TrayEntry(const TrayEntry& other) = delete;
 
  constexpr TrayEntry(TrayEntry&& other) = default;
 
  ~TrayEntry() { reset(); }
 
  TrayEntry& operator=(TrayEntry other)
  {
    reset(other.release());
    return *this;
  }
};
 
inline TrayMenu TrayBase::CreateMenu() { return SDL_CreateTrayMenu(get()); }
 
inline TrayMenu TrayBase::GetMenu() const { return SDL_GetTrayMenu(get()); }
 
inline std::span<TrayEntry> TrayMenu::GetEntries()
{
  int count;
  auto entries = SDL_GetTrayEntries(m_trayMenu, &count);
  return std::span<TrayEntry>{reinterpret_cast<TrayEntry*>(entries),
                              size_t(count)};
}
 
inline DetachedTrayEntry TrayMenu::InsertEntry(int pos,
                                               StringParam label,
                                               TrayEntryFlags flags)
{
  return SDL_InsertTrayEntryAt(m_trayMenu, pos, label, flags);
}
 
inline TrayEntryRef TrayMenu::GetParentEntry() const
{
  return SDL_GetTrayMenuParentEntry(m_trayMenu);
}
 
inline TrayRef TrayMenu::GetParentTray() const
{
  return SDL_GetTrayMenuParentTray(m_trayMenu);
}
 
inline void UpdateTrays() { SDL_UpdateTrays(); }
 
#pragma region impl
 
inline DetachedTrayEntry TrayMenu::AppendEntry(StringParam label,
                                               TrayEntryFlags flags)
{
  return InsertEntry(-1, std::move(label), flags);
}
 
void TrayEntryBase::SetCallback(TrayCB callback)
{
  using Wrapper = KeyValueCallbackWrapper<SDL_TrayEntry*, TrayCB>;
  SetCallback(
    [](void* userdata, SDL_TrayEntry* entry) {
      Wrapper::Call(userdata, TrayEntryRef{entry});
    },
    Wrapper::Wrap(get(), std::move(callback)));
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_TRAY_H_ */