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*;

using TrayRef = ResourceRef<Tray>;

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)>;

struct Tray : ResourceBase<TrayRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Tray(TrayRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Tray(const Tray& other) = 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(get()); }

  constexpr Tray& operator=(Tray&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Tray& operator=(const Tray& other) = delete;

  void Destroy();

  void SetIcon(SurfaceRef icon);

  void SetTooltip(StringParam tooltip);

  TrayMenu CreateMenu();

  TrayMenu GetMenu() const;
};

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);

  TrayEntry GetParentEntry() const;

  TrayRef GetParentTray() const;
};

struct TrayEntry : ResourceBase<TrayEntryRaw>
{
  using ResourceBase::ResourceBase;

  TrayEntry(TrayMenu menu, int pos, StringParam label, TrayEntryFlags flags);

  TrayEntry(TrayMenuRaw menu, StringParam label, TrayEntryFlags flags);

  constexpr operator TrayEntryRaw() const noexcept { return get(); }

  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(TrayCallback callback, void* userdata);

  void SetCallback(TrayCB callback);

  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)
  : Tray(SDL_CreateTray(icon, tooltip))
{
}

inline void SetTrayIcon(TrayRef tray, SurfaceRef icon)
{
  SDL_SetTrayIcon(tray, icon);
}
 
inline void Tray::SetIcon(SurfaceRef icon) { SDL::SetTrayIcon(get(), icon); }

inline void SetTrayTooltip(TrayRef tray, StringParam tooltip)
{
  SDL_SetTrayTooltip(tray, tooltip);
}
 
inline void Tray::SetTooltip(StringParam tooltip)
{
  SDL::SetTrayTooltip(get(), std::move(tooltip));
}

inline TrayMenu CreateTrayMenu(TrayRef tray)
{
  return SDL_CreateTrayMenu(tray);
}
 
inline TrayMenu Tray::CreateMenu() { return SDL::CreateTrayMenu(get()); }

inline TrayMenu CreateTraySubmenu(TrayEntry entry)
{
  return SDL_CreateTraySubmenu(entry);
}
 
inline TrayMenu TrayEntry::CreateSubmenu()
{
  return SDL::CreateTraySubmenu(get());
}

inline TrayMenu GetTrayMenu(TrayRef tray) { return SDL_GetTrayMenu(tray); }
 
inline TrayMenu Tray::GetMenu() const { return SDL::GetTrayMenu(get()); }

inline TrayMenu GetTraySubmenu(TrayEntry entry)
{
  return SDL_GetTraySubmenu(entry);
}
 
inline TrayMenu TrayEntry::GetSubmenu() { return SDL::GetTraySubmenu(get()); }

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 TrayEntry(menu, pos, std::move(label), flags);
}
 
inline TrayEntry TrayMenu::InsertEntry(int pos,
                                       StringParam label,
                                       TrayEntryFlags flags)
{
  return TrayEntry(m_trayMenu, pos, std::move(label), flags);
}
 
inline TrayEntry::TrayEntry(TrayMenu menu,
                            int pos,
                            StringParam label,
                            TrayEntryFlags flags)
  : TrayEntry(SDL_InsertTrayEntryAt(menu, pos, label, flags))
{
}
 
inline TrayEntry::TrayEntry(TrayMenuRaw menu,
                            StringParam label,
                            TrayEntryFlags flags)
  : TrayEntry(menu, -1, std::move(label), flags)
{
}

inline TrayEntry AppendTrayEntry(TrayMenuRaw menu,
                                 StringParam label,
                                 TrayEntryFlags flags)
{
  return TrayEntry(menu, std::move(label), flags);
}
 
inline TrayEntry TrayMenu::AppendEntry(StringParam label, TrayEntryFlags flags)
{
  return SDL::AppendTrayEntry(m_trayMenu, std::move(label), flags);
}

inline void SetTrayEntryLabel(TrayEntry entry, StringParam label)
{
  SDL_SetTrayEntryLabel(entry, label);
}
 
inline void TrayEntry::SetLabel(StringParam label)
{
  SDL::SetTrayEntryLabel(get(), std::move(label));
}

inline const char* GetTrayEntryLabel(TrayEntryRef entry)
{
  return SDL_GetTrayEntryLabel(entry);
}
 
inline const char* TrayEntry::GetLabel() const
{
  return SDL::GetTrayEntryLabel(get());
}

inline void SetTrayEntryChecked(TrayEntry entry, bool checked)
{
  SDL_SetTrayEntryChecked(entry, checked);
}
 
inline void TrayEntry::SetChecked(bool checked)
{
  SDL::SetTrayEntryChecked(get(), checked);
}

inline bool GetTrayEntryChecked(TrayEntryRef entry)
{
  return SDL_GetTrayEntryChecked(entry);
}
 
inline bool TrayEntry::GetChecked() const
{
  return SDL::GetTrayEntryChecked(get());
}

inline void SetTrayEntryEnabled(TrayEntry entry, bool enabled)
{
  SDL_SetTrayEntryEnabled(entry, enabled);
}
 
inline void TrayEntry::SetEnabled(bool enabled)
{
  SDL::SetTrayEntryEnabled(get(), enabled);
}

inline bool GetTrayEntryEnabled(TrayEntryRef entry)
{
  return SDL_GetTrayEntryEnabled(entry);
}
 
inline bool TrayEntry::GetEnabled() const
{
  return SDL::GetTrayEntryEnabled(get());
}

inline void SetTrayEntryCallback(TrayEntry entry,
                                 TrayCallback callback,
                                 void* userdata)
{
  SDL_SetTrayEntryCallback(entry, callback, userdata);
}

inline void SetTrayEntryCallback(TrayEntry entry, TrayCB callback)
{
  SetTrayEntryCallback(entry, callback.wrapper, callback.data);
}
 
inline void TrayEntry::SetCallback(TrayCallback callback, void* userdata)
{
  SDL::SetTrayEntryCallback(get(), callback, userdata);
}
 
inline void TrayEntry::SetCallback(TrayCB callback)
{
  SetTrayEntryCallback(get(), callback);
}

inline void ClickTrayEntry(TrayEntry entry) { SDL_ClickTrayEntry(entry); }
 
inline void TrayEntry::Click() { SDL::ClickTrayEntry(get()); }

inline void DestroyTray(TrayRaw tray) { SDL_DestroyTray(tray); }
 
inline void Tray::Destroy() { DestroyTray(release()); }

inline TrayMenu GetTrayEntryParent(TrayEntry entry)
{
  return SDL_GetTrayEntryParent(entry);
}
 
inline TrayMenu TrayEntry::GetParent()
{
  return SDL::GetTrayEntryParent(get());
}

inline TrayEntry GetTrayMenuParentEntry(TrayMenuRaw menu)
{
  return SDL_GetTrayMenuParentEntry(menu);
}
 
inline TrayEntry 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(); }

 
} // namespace SDL
 
#endif /* SDL3PP_TRAY_H_ */