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 Tray;
 
using TrayRaw = SDL_Tray*;
 
// Forward decl
struct TrayRef;
 
using TrayMenuRaw = SDL_TrayMenu*;
 
// Forward decl
struct TrayMenu;
 
// Forward decl
struct TrayEntry;
 
using TrayEntryRaw = SDL_TrayEntry*;
 
// Forward decl
struct TrayEntryScoped;
 
using 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;
 
using TrayCallback = void(SDLCALL*)(void* userdata, TrayEntryRaw entry);
 
using TrayCB = MakeFrontCallback<void(TrayEntryRaw entry)>;
 
class Tray
{
  TrayRaw m_resource = nullptr;
 
public:
  constexpr Tray(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr explicit Tray(TrayRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Tray(const Tray& other) noexcept = delete;
 
  constexpr Tray(Tray&& other) noexcept
    : Tray(other.release())
  {
  }
 
  constexpr Tray(const TrayRef& other) = delete;
 
  constexpr Tray(TrayRef&& other) = delete;
 
  Tray(SurfaceRef icon, StringParam tooltip);
 
  ~Tray() { SDL_DestroyTray(m_resource); }
 
  constexpr Tray& operator=(Tray&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  Tray& operator=(const Tray& other) = delete;
 
  constexpr TrayRaw get() const noexcept { return m_resource; }
 
  constexpr TrayRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Tray& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  void SetIcon(SurfaceRef icon);
 
  void SetTooltip(StringParam tooltip);
 
  TrayMenu CreateMenu();
 
  TrayMenu GetMenu() const;
};
 
struct TrayRef : Tray
{
  using Tray::Tray;
 
  constexpr TrayRef(TrayRaw resource) noexcept
    : Tray(resource)
  {
  }
 
  constexpr TrayRef(const Tray& resource) noexcept
    : Tray(resource.get())
  {
  }
 
  constexpr TrayRef(Tray&& resource) noexcept
    : Tray(std::move(resource).release())
  {
  }
 
  constexpr TrayRef(const TrayRef& other) noexcept
    : Tray(other.get())
  {
  }
 
  constexpr TrayRef(TrayRef&& other) noexcept
    : Tray(other.get())
  {
  }
 
  ~TrayRef() { release(); }
 
  TrayRef& operator=(const TrayRef& other) noexcept
  {
    release();
    Tray::operator=(Tray(other.get()));
    return *this;
  }
 
  constexpr operator TrayRaw() const noexcept { return get(); }
};
 
class TrayMenu
{
  TrayMenuRaw m_trayMenu;
 
public:
  constexpr TrayMenu(TrayMenuRaw trayMenu = {}) noexcept
    : m_trayMenu(trayMenu)
  {
  }
 
  constexpr operator TrayMenuRaw() const noexcept { return m_trayMenu; }
 
  std::span<TrayEntry> GetEntries();
 
  TrayEntry InsertEntry(int pos, StringParam label, TrayEntryFlags flags);
 
  TrayEntry AppendEntry(StringParam label, TrayEntryFlags flags);
 
  TrayEntryRef GetParentEntry() const;
 
  TrayRef GetParentTray() const;
};
 
class TrayEntry
{
  TrayEntryRaw m_resource = nullptr;
 
public:
  constexpr TrayEntry(std::nullptr_t = nullptr) noexcept
    : m_resource(nullptr)
  {
  }
 
  constexpr TrayEntry(TrayEntryRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr operator TrayEntryRaw() const noexcept { return m_resource; }
 
  constexpr TrayEntryRaw get() const noexcept { return m_resource; }
 
  constexpr TrayEntryRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const TrayEntry& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Remove();
 
  TrayMenu CreateSubmenu();
 
  TrayMenu GetSubmenu();
 
  void SetLabel(StringParam label);
 
  const char* GetLabel() const;
 
  void SetChecked(bool checked);
 
  bool GetChecked() const;
 
  void SetEnabled(bool enabled);
 
  bool GetEnabled() const;
 
  void SetCallback(TrayCB callback);
 
  void SetCallback(TrayCallback callback, void* userdata);
 
  void Click();
 
  TrayMenu GetParent();
};
 
struct TrayEntryScoped : TrayEntry
{
  using TrayEntry::TrayEntry;
 
  constexpr TrayEntryScoped(const TrayEntryScoped& other) = delete;
 
  constexpr TrayEntryScoped(TrayEntryScoped&& other) noexcept
    : TrayEntry(other.release())
  {
  }
 
  constexpr TrayEntryScoped(TrayEntry&& other) noexcept
    : TrayEntry(std::move(other).release())
  {
  }
 
  ~TrayEntryScoped() { Remove(); }
};
 
inline Tray CreateTray(SurfaceRef icon, StringParam tooltip)
{
  return Tray(icon, std::move(tooltip));
}
 
inline Tray::Tray(SurfaceRef icon, StringParam tooltip)
  : m_resource(SDL_CreateTray(icon, tooltip))
{
}
 
inline void SetTrayIcon(TrayRef tray, SurfaceRef icon)
{
  SDL_SetTrayIcon(tray, icon);
}
 
inline void Tray::SetIcon(SurfaceRef icon)
{
  SDL::SetTrayIcon(m_resource, icon);
}
 
inline void SetTrayTooltip(TrayRef tray, StringParam tooltip)
{
  SDL_SetTrayTooltip(tray, tooltip);
}
 
inline void Tray::SetTooltip(StringParam tooltip)
{
  SDL::SetTrayTooltip(m_resource, std::move(tooltip));
}
 
inline TrayMenu CreateTrayMenu(TrayRef tray)
{
  return SDL_CreateTrayMenu(tray);
}
 
inline TrayMenu Tray::CreateMenu() { return SDL::CreateTrayMenu(m_resource); }
 
inline TrayMenu CreateTraySubmenu(TrayEntryRef entry)
{
  return SDL_CreateTraySubmenu(entry);
}
 
inline TrayMenu TrayEntry::CreateSubmenu()
{
  return SDL::CreateTraySubmenu(m_resource);
}
 
inline TrayMenu GetTrayMenu(TrayRef tray) { return SDL_GetTrayMenu(tray); }
 
inline TrayMenu Tray::GetMenu() const { return SDL::GetTrayMenu(m_resource); }
 
inline TrayMenu GetTraySubmenu(TrayEntryRef entry)
{
  return SDL_GetTraySubmenu(entry);
}
 
inline TrayMenu TrayEntry::GetSubmenu()
{
  return SDL::GetTraySubmenu(m_resource);
}
 
inline std::span<TrayEntry> GetTrayEntries(TrayMenu menu)
{
  int count;
  auto entries = SDL_GetTrayEntries(menu, &count);
  return std::span<TrayEntry>{reinterpret_cast<TrayEntry*>(entries),
                              size_t(count)};
}
 
inline std::span<TrayEntry> TrayMenu::GetEntries()
{
  return SDL::GetTrayEntries(m_trayMenu);
}
 
inline void RemoveTrayEntry(TrayEntryRaw entry) { SDL_RemoveTrayEntry(entry); }
 
inline void TrayEntry::Remove() { RemoveTrayEntry(release()); }
 
inline TrayEntry InsertTrayEntryAt(TrayMenu menu,
                                   int pos,
                                   StringParam label,
                                   TrayEntryFlags flags)
{
  return SDL_InsertTrayEntryAt(menu, pos, label, flags);
}
 
inline TrayEntry TrayMenu::InsertEntry(int pos,
                                       StringParam label,
                                       TrayEntryFlags flags)
{
  return SDL::InsertTrayEntryAt(m_trayMenu, pos, std::move(label), flags);
}
 
inline void SetTrayEntryLabel(TrayEntryRef entry, StringParam label)
{
  SDL_SetTrayEntryLabel(entry, label);
}
 
inline void TrayEntry::SetLabel(StringParam label)
{
  SDL::SetTrayEntryLabel(m_resource, std::move(label));
}
 
inline const char* GetTrayEntryLabel(TrayEntryRef entry)
{
  return SDL_GetTrayEntryLabel(entry);
}
 
inline const char* TrayEntry::GetLabel() const
{
  return SDL::GetTrayEntryLabel(m_resource);
}
 
inline void SetTrayEntryChecked(TrayEntryRef entry, bool checked)
{
  SDL_SetTrayEntryChecked(entry, checked);
}
 
inline void TrayEntry::SetChecked(bool checked)
{
  SDL::SetTrayEntryChecked(m_resource, checked);
}
 
inline bool GetTrayEntryChecked(TrayEntryRef entry)
{
  return SDL_GetTrayEntryChecked(entry);
}
 
inline bool TrayEntry::GetChecked() const
{
  return SDL::GetTrayEntryChecked(m_resource);
}
 
inline void SetTrayEntryEnabled(TrayEntryRef entry, bool enabled)
{
  SDL_SetTrayEntryEnabled(entry, enabled);
}
 
inline void TrayEntry::SetEnabled(bool enabled)
{
  SDL::SetTrayEntryEnabled(m_resource, enabled);
}
 
inline bool GetTrayEntryEnabled(TrayEntryRef entry)
{
  return SDL_GetTrayEntryEnabled(entry);
}
 
inline bool TrayEntry::GetEnabled() const
{
  return SDL::GetTrayEntryEnabled(m_resource);
}
 
inline void SetTrayEntryCallback(TrayEntryRef entry,
                                 TrayCallback callback,
                                 void* userdata)
{
  SDL_SetTrayEntryCallback(entry, callback, userdata);
}
 
inline void TrayEntry::SetCallback(TrayCallback callback, void* userdata)
{
  SDL::SetTrayEntryCallback(m_resource, callback, userdata);
}
 
inline void ClickTrayEntry(TrayEntryRef entry) { SDL_ClickTrayEntry(entry); }
 
inline void TrayEntry::Click() { SDL::ClickTrayEntry(m_resource); }
 
inline void DestroyTray(TrayRaw tray) { SDL_DestroyTray(tray); }
 
inline void Tray::Destroy() { DestroyTray(release()); }
 
inline TrayMenu GetTrayEntryParent(TrayEntryRef entry)
{
  return SDL_GetTrayEntryParent(entry);
}
 
inline TrayMenu TrayEntry::GetParent()
{
  return SDL::GetTrayEntryParent(m_resource);
}
 
inline TrayEntryRef GetTrayMenuParentEntry(TrayMenuRaw menu)
{
  return SDL_GetTrayMenuParentEntry(menu);
}
 
inline TrayEntryRef TrayMenu::GetParentEntry() const
{
  return SDL::GetTrayMenuParentEntry(m_trayMenu);
}
 
inline TrayRef GetTrayMenuParentTray(TrayMenuRaw menu)
{
  return SDL_GetTrayMenuParentTray(menu);
}
 
inline TrayRef TrayMenu::GetParentTray() const
{
  return SDL::GetTrayMenuParentTray(m_trayMenu);
}
 
inline void UpdateTrays() { SDL_UpdateTrays(); }
 
 
inline TrayEntry TrayMenu::AppendEntry(StringParam label, TrayEntryFlags flags)
{
  return InsertEntry(-1, std::move(label), flags);
}
 
inline void TrayEntry::SetCallback(TrayCB callback)
{
  SetCallback(callback.wrapper, callback.data);
}
 
} // namespace SDL
 
#endif /* SDL3PP_TRAY_H_ */