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;
 
struct TrayParam
{
  TrayRaw value; 
 
  constexpr TrayParam(TrayRaw value)
    : value(value)
  {
  }
 
  constexpr TrayParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TrayParam& other) const = default;
 
  constexpr operator TrayRaw() const { return value; }
};
 
struct TrayMenu;
 
using TrayMenuRaw = SDL_TrayMenu*;
 
// Forward decl
struct TrayMenu;
 
// Forward decl
struct TrayEntry;
 
using TrayEntryRaw = SDL_TrayEntry*;
 
// Forward decl
struct TrayEntryScoped;
 
struct TrayEntryParam
{
  TrayEntryRaw value; 
 
  constexpr TrayEntryParam(TrayEntryRaw value)
    : value(value)
  {
  }
 
  constexpr TrayEntryParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const TrayEntryParam& other) const = default;
 
  constexpr operator TrayEntryRaw() const { return value; }
};
 
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 = SDL_TrayCallback;
 
using TrayCB = std::function<void(TrayEntryRaw)>;
 
class Tray
{
  TrayRaw m_resource = nullptr;
 
public:
  constexpr Tray() = default;
 
  constexpr explicit Tray(const TrayRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Tray(const Tray& other) = delete;
 
  constexpr Tray(Tray&& other)
    : Tray(other.release())
  {
  }
 
  constexpr Tray(const TrayRef& other) = delete;
 
  constexpr Tray(TrayRef&& other) = delete;
 
  Tray(SurfaceParam icon, StringParam tooltip)
    : m_resource(SDL_CreateTray(icon, tooltip))
  {
  }
 
  ~Tray() { SDL_DestroyTray(m_resource); }
 
  Tray& operator=(Tray other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr TrayRaw get() const { return m_resource; }
 
  constexpr TrayRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Tray& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator TrayParam() const { return {m_resource}; }
 
  void Destroy();
 
  void SetIcon(SurfaceParam icon);
 
  void SetTooltip(StringParam tooltip);
 
  TrayMenu CreateMenu();
 
  TrayMenu GetMenu() const;
};
 
struct TrayRef : Tray
{
  TrayRef(TrayParam resource)
    : Tray(resource.value)
  {
  }
 
  TrayRef(const TrayRef& other)
    : Tray(other.get())
  {
  }
 
  ~TrayRef() { release(); }
};
 
class TrayMenu
{
  TrayMenuRaw m_trayMenu;
 
public:
  constexpr TrayMenu(TrayMenuRaw trayMenu = {})
    : m_trayMenu(trayMenu)
  {
  }
 
  constexpr operator TrayMenuRaw() const { return m_trayMenu; }
 
  std::span<TrayEntry> GetEntries();
 
  TrayEntry InsertEntry(int pos, StringParam label, TrayEntryFlags flags);
 
  TrayEntry AppendEntry(StringParam label, TrayEntryFlags flags);
 
  TrayEntryParam GetParentEntry() const;
 
  TrayParam GetParentTray() const;
};
 
class TrayEntry
{
  TrayEntryRaw m_resource = nullptr;
 
public:
  constexpr TrayEntry() = default;
 
  constexpr TrayEntry(const TrayEntryRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr TrayEntry(const TrayEntry& other) = default;
 
  constexpr TrayEntry(TrayEntry&& other)
    : TrayEntry(other.release())
  {
  }
 
  ~TrayEntry() {}
 
  TrayEntry& operator=(TrayEntry other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr TrayEntryRaw get() const { return m_resource; }
 
  constexpr TrayEntryRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const TrayEntry& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator TrayEntryParam() const { 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 TrayEntry& other) = delete;
 
  constexpr TrayEntryScoped(TrayEntry&& other)
    : TrayEntry(other.release())
  {
  }
 
  ~TrayEntryScoped() { Remove(); }
};
 
inline Tray CreateTray(SurfaceParam icon, StringParam tooltip)
{
  return Tray(icon, std::move(tooltip));
}
 
inline void SetTrayIcon(TrayParam tray, SurfaceParam icon)
{
  SDL_SetTrayIcon(tray, icon);
}
 
inline void Tray::SetIcon(SurfaceParam icon)
{
  SDL::SetTrayIcon(m_resource, icon);
}
 
inline void SetTrayTooltip(TrayParam tray, StringParam tooltip)
{
  SDL_SetTrayTooltip(tray, tooltip);
}
 
inline void Tray::SetTooltip(StringParam tooltip)
{
  SDL::SetTrayTooltip(m_resource, std::move(tooltip));
}
 
inline TrayMenu CreateTrayMenu(TrayParam tray)
{
  return SDL_CreateTrayMenu(tray);
}
 
inline TrayMenu Tray::CreateMenu() { return SDL::CreateTrayMenu(m_resource); }
 
inline TrayMenu CreateTraySubmenu(TrayEntryParam entry)
{
  return SDL_CreateTraySubmenu(entry);
}
 
inline TrayMenu TrayEntry::CreateSubmenu()
{
  return SDL::CreateTraySubmenu(m_resource);
}
 
inline TrayMenu GetTrayMenu(TrayParam tray) { return SDL_GetTrayMenu(tray); }
 
inline TrayMenu Tray::GetMenu() const { return SDL::GetTrayMenu(m_resource); }
 
inline TrayMenu GetTraySubmenu(TrayEntryParam 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(TrayEntryParam entry, StringParam label)
{
  SDL_SetTrayEntryLabel(entry, label);
}
 
inline void TrayEntry::SetLabel(StringParam label)
{
  SDL::SetTrayEntryLabel(m_resource, std::move(label));
}
 
inline const char* GetTrayEntryLabel(TrayEntryParam entry)
{
  return SDL_GetTrayEntryLabel(entry);
}
 
inline const char* TrayEntry::GetLabel() const
{
  return SDL::GetTrayEntryLabel(m_resource);
}
 
inline void SetTrayEntryChecked(TrayEntryParam entry, bool checked)
{
  SDL_SetTrayEntryChecked(entry, checked);
}
 
inline void TrayEntry::SetChecked(bool checked)
{
  SDL::SetTrayEntryChecked(m_resource, checked);
}
 
inline bool GetTrayEntryChecked(TrayEntryParam entry)
{
  return SDL_GetTrayEntryChecked(entry);
}
 
inline bool TrayEntry::GetChecked() const
{
  return SDL::GetTrayEntryChecked(m_resource);
}
 
inline void SetTrayEntryEnabled(TrayEntryParam entry, bool enabled)
{
  SDL_SetTrayEntryEnabled(entry, enabled);
}
 
inline void TrayEntry::SetEnabled(bool enabled)
{
  SDL::SetTrayEntryEnabled(m_resource, enabled);
}
 
inline bool GetTrayEntryEnabled(TrayEntryParam entry)
{
  return SDL_GetTrayEntryEnabled(entry);
}
 
inline bool TrayEntry::GetEnabled() const
{
  return SDL::GetTrayEntryEnabled(m_resource);
}
 
inline void SetTrayEntryCallback(TrayEntryParam 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(TrayEntryParam 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(TrayEntryParam entry)
{
  return SDL_GetTrayEntryParent(entry);
}
 
inline TrayMenu TrayEntry::GetParent()
{
  return SDL::GetTrayEntryParent(m_resource);
}
 
inline TrayEntryParam GetTrayMenuParentEntry(TrayMenuRaw menu)
{
  return SDL_GetTrayMenuParentEntry(menu);
}
 
inline TrayEntryParam TrayMenu::GetParentEntry() const
{
  return SDL::GetTrayMenuParentEntry(m_trayMenu);
}
 
inline TrayParam GetTrayMenuParentTray(TrayMenuRaw menu)
{
  return SDL_GetTrayMenuParentTray(menu);
}
 
inline TrayParam 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)
{
  using Wrapper = KeyValueCallbackWrapper<SDL_TrayEntry*, TrayCB>;
  SetCallback([](void* userdata,
                 SDL_TrayEntry* entry) { Wrapper::Call(userdata, entry); },
              Wrapper::Wrap(get(), std::move(callback)));
}
 
} // namespace SDL
 
#endif /* SDL3PP_TRAY_H_ */