SDL3pp_system.h

#ifndef SDL3PP_SYSTEM_H_
#define SDL3PP_SYSTEM_H_
 
#include <SDL3/SDL_system.h>
#include "SDL3pp_keyboard.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_video.h"
 
namespace SDL {

 
/*
 * Platform specific functions for Windows
 */
#if defined(SDL_PLATFORM_WINDOWS) || defined(SDL3PP_DOC)

using MSG = ::MSG;

using WindowsMessageHook = bool(SDLCALL*)(void* userdata, MSG* msg);

inline void SetWindowsMessageHook(WindowsMessageHook callback, void* userdata)
{
  SDL_SetWindowsMessageHook(callback, userdata);
}
 
#endif // SDL_PLATFORM_WINDOWS
 
#if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK) ||             \
  defined(SDL3PP_DOC)

inline int GetDirect3D9AdapterIndex(Display displayID)
{
  return CheckError(SDL_GetDirect3D9AdapterIndex(displayID));
}

inline void GetDXGIOutputInfo(Display displayID,
                              int* adapterIndex,
                              int* outputIndex)
{
  CheckError(SDL_GetDXGIOutputInfo(displayID, adapterIndex, outputIndex));
}
 
#endif // defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK)

using XEvent = ::XEvent;

using X11EventHook = bool(SDLCALL*)(void* userdata, XEvent* xevent);

inline void SetX11EventHook(X11EventHook callback, void* userdata)
{
  SDL_SetX11EventHook(callback, userdata);
}
 
/* Platform specific functions for Linux*/
#if defined(SDL_PLATFORM_LINUX) || defined(SDL3PP_DOC)

inline void SetLinuxThreadPriority(Sint64 threadID, int priority)
{
  CheckError(SDL_SetLinuxThreadPriority(threadID, priority));
}

inline void SetLinuxThreadPriorityAndPolicy(Sint64 threadID,
                                            int sdlPriority,
                                            int schedPolicy)
{
  CheckError(
    SDL_SetLinuxThreadPriorityAndPolicy(threadID, sdlPriority, schedPolicy));
}
 
#endif // SDL_PLATFORM_LINUX
 
/*
 * Platform specific functions for iOS
 */
#if defined(SDL_PLATFORM_IOS) || defined(SDL3PP_DOC)

using iOSAnimationCallback = void(SDLCALL*)(void* userdata);

inline void SetiOSAnimationCallback(WindowRef window,
                                    int interval,
                                    iOSAnimationCallback callback,
                                    void* callbackParam)
{
  CheckError(
    SDL_SetiOSAnimationCallback(window, interval, callback, callbackParam));
}

inline void SetiOSEventPump(bool enabled) { SDL_SetiOSEventPump(enabled); }
 
#endif // defined(SDL_PLATFORM_IOS)
 
/*
 * Platform specific functions for Android
 */
#if defined(SDL_PLATFORM_ANDROID) || defined(SDL3PP_DOC)

inline void* GetAndroidJNIEnv() { return CheckError(SDL_GetAndroidJNIEnv()); }

inline void* GetAndroidActivity()
{
  return CheckError(SDL_GetAndroidActivity());
}

inline int GetAndroidSDKVersion() { return SDL_GetAndroidSDKVersion(); }

inline bool IsChromebook() { return SDL_IsChromebook(); }

inline bool IsDeXMode() { return SDL_IsDeXMode(); }

inline void SendAndroidBackButton() { SDL_SendAndroidBackButton(); }

constexpr Uint32 ANDROID_EXTERNAL_STORAGE_READ =
  SDL_ANDROID_EXTERNAL_STORAGE_READ;

constexpr Uint32 ANDROID_EXTERNAL_STORAGE_WRITE =
  SDL_ANDROID_EXTERNAL_STORAGE_WRITE;

inline const char* GetAndroidInternalStoragePath()
{
  return SDL_GetAndroidInternalStoragePath();
}

inline Uint32 GetAndroidExternalStorageState()
{
  return SDL_GetAndroidExternalStorageState();
}

inline const char* GetAndroidExternalStoragePath()
{
  return CheckError(SDL_GetAndroidExternalStoragePath());
}

inline const char* GetAndroidCachePath()
{
  return CheckError(SDL_GetAndroidCachePath());
}

using RequestAndroidPermissionCallback = void(SDLCALL*)(void* userdata,
                                                        const char* permission,
                                                        bool granted);

using RequestAndroidPermissionCB =
  std::function<void(const char* permission, bool granted)>;

inline bool RequestAndroidPermission(StringParam permission,
                                     RequestAndroidPermissionCallback cb,
                                     void* userdata)
{
  return SDL_RequestAndroidPermission(permission, cb, userdata);
}

inline bool RequestAndroidPermission(StringParam permission,
                                     RequestAndroidPermissionCB cb)
{
  using Wrapper = CallbackWrapper<RequestAndroidPermissionCB>;
  auto callback = Wrapper::Wrap(std::move(cb));
  if (!RequestAndroidPermission(permission, &Wrapper::CallOnce, callback)) {
    Wrapper::release(callback);
  }
}

inline void ShowAndroidToast(StringParam message,
                             int duration,
                             int gravity,
                             int xoffset,
                             int yoffset)
{
  CheckError(
    SDL_ShowAndroidToast(message, duration, gravity, xoffset, yoffset));
}

inline void SendAndroidMessage(Uint32 command, int param)
{
  CheckError(SDL_SendAndroidMessage(command, param));
}
 
#endif // defined(SDL_PLATFORM_ANDROID)

inline bool IsTablet() { return SDL_IsTablet(); }

inline bool IsTV() { return SDL_IsTV(); }

using Sandbox = SDL_Sandbox;
 
constexpr Sandbox SANDBOX_NONE = SDL_SANDBOX_NONE; 
 
constexpr Sandbox SANDBOX_UNKNOWN_CONTAINER =
  SDL_SANDBOX_UNKNOWN_CONTAINER; 
 
constexpr Sandbox SANDBOX_FLATPAK = SDL_SANDBOX_FLATPAK; 
 
constexpr Sandbox SANDBOX_SNAP = SDL_SANDBOX_SNAP; 
 
constexpr Sandbox SANDBOX_MACOS = SDL_SANDBOX_MACOS; 

inline Sandbox GetSandbox() { return SDL_GetSandbox(); }

inline void OnApplicationWillTerminate() { SDL_OnApplicationWillTerminate(); }

inline void OnApplicationDidReceiveMemoryWarning()
{
  SDL_OnApplicationDidReceiveMemoryWarning();
}

inline void OnApplicationWillEnterBackground()
{
  SDL_OnApplicationWillEnterBackground();
}

inline void OnApplicationDidEnterBackground()
{
  SDL_OnApplicationDidEnterBackground();
}

inline void OnApplicationWillEnterForeground()
{
  SDL_OnApplicationWillEnterForeground();
}

inline void OnApplicationDidEnterForeground()
{
  SDL_OnApplicationDidEnterForeground();
}
 
#if defined(SDL_PLATFORM_IOS) || defined(SDL3PP_DOC)

inline void OnApplicationDidChangeStatusBarOrientation()
{
  SDL_OnApplicationDidChangeStatusBarOrientation();
}
 
#endif // defined(SDL_PLATFORM_IOS)
 
#if defined(SDL_PLATFORM_GDK) || defined(SDL3PP_DOC)

using XTaskQueueHandle = ::XTaskQueueHandle;

using XUserHandle = ::XUserHandle;

inline void GetGDKTaskQueue(XTaskQueueHandle* outTaskQueue)
{
  CheckError(SDL_GetGDKTaskQueue(outTaskQueue));
}

inline bool GetGDKDefaultUser(XUserHandle* outUserHandle)
{
  return SDL_GetGDKDefaultUser(outUserHandle);
}
#endif // defined(SDL_PLATFORM_GDK)

 
} // namespace SDL
 
#endif /* SDL3PP_SYSTEM_H_ */