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 TrayRef;
 
// Forward decl
struct Tray;
 
using TrayShared = ResourceShared<Tray>;
 
using TrayWeak = ResourceWeak<Tray>;
 
// Forward decl
struct TrayEntryRef;
 
// Forward decl
struct TrayEntry;
 
using TrayEntryShared = ResourceShared<TrayEntry>;
 
using TrayEntryWeak = ResourceWeak<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 TrayRef : Resource<SDL_Tray*>
{
  using Resource::Resource;
 
  void SetIcon(SurfaceRef icon) { SDL_SetTrayIcon(get(), icon.get()); }
 
  void SetTooltip(StringParam tooltip) { SDL_SetTrayTooltip(get(), tooltip); }
 
  TrayMenu CreateMenu();
 
  TrayMenu GetMenu() const;
 
  static void reset(SDL_Tray* resource) { SDL_DestroyTray(resource); }
};
 
struct Tray : ResourceUnique<TrayRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Tray Create(SurfaceRef icon, StringParam tooltip)
  {
    return Tray(SDL_CreateTray(icon, tooltip));
  }
 
  void Destroy() { reset(); }
  TrayShared share();
 
};
 
 
inline TrayShared Tray::share()
{
  return TrayShared(std::move(*this));
}
 
struct TrayUnsafe : ResourceUnsafe<TrayRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit TrayUnsafe(Tray&& other)
    : TrayUnsafe(other.release())
  {
  }
};
 
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 TrayEntryRef : 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()); }
 
  static void reset(SDL_TrayEntry* resource) { SDL_RemoveTrayEntry(resource); }
};
 
struct TrayEntry : ResourceUnique<TrayEntryRef>
{
  using ResourceUnique::ResourceUnique;
 
  void Remove() { reset(); }
  TrayEntryShared share();
 
};
 
 
inline TrayEntryShared TrayEntry::share()
{
  return TrayEntryShared(std::move(*this));
}
 
struct TrayEntryUnsafe : ResourceUnsafe<TrayEntryRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit TrayEntryUnsafe(TrayEntry&& other)
    : TrayEntryUnsafe(other.release())
  {
  }
};
 
inline TrayMenu TrayRef::CreateMenu() { return SDL_CreateTrayMenu(get()); }
 
inline TrayMenu TrayRef::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 DetachedTrayEntry(
    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);
}
 
inline void TrayEntryRef::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_ */