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 WindowsMessageHook = SDL_WindowsMessageHook;
 
using WindowsMessageHookCB = std::function<bool (MSG *)>;
 
inline void SetWindowsMessageHook(WindowsMessageHook callback, void* userdata)
{
  SDL_SetWindowsMessageHook(callback, userdata);
}
 
inline void SetWindowsMessageHook(WindowsMessageHookCB callback)
{
  using Wrapper = UniqueCallbackWrapper<WindowsMessageHookCB>;
  SetWindowsMessageHook(&Wrapper::CallSuffixed,
                        Wrapper::Wrap(std::move(callback)));
}
#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 X11EventHook = SDL_X11EventHook;
 
using X11EventHookCB = std::function<bool(XEvent*)>;
 
inline void SetX11EventHook(X11EventHook callback, void* userdata)
{
  SDL_SetX11EventHook(callback, userdata);
}
 
inline void SetX11EventHook(X11EventHookCB callback)
{
  using Wrapper = UniqueCallbackWrapper<X11EventHookCB>;
  SDL_SetX11EventHook(&Wrapper::Call, Wrapper::Wrap(std::move(callback)));
}
 
/* 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 = SDL_iOSAnimationCallback;
 
using iOSAnimationCB = std::function<void ()>;
 
inline void SetiOSAnimationCallback(WindowBase& window,
                                    int interval,
                                    iOSAnimationCallback callback,
                                    void* callbackParam)
{
  CheckError(
    SDL_SetiOSAnimationCallback(window, interval, callback, callbackParam));
}
 
inline void SetiOSAnimationCallback(WindowBase& window,
                                    int interval,
                                    iOSAnimationCB callback)
{
  using Wrapper = UniqueCallbackWrapper<iOSAnimationCB>;
  SetiOSAnimationCallback(&Wrapper::Call, Wrapper::Wrap(std::move(callback)));
}
 
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 SDL_GetAndroidJNIEnv(); }
 
inline void* GetAndroidActivity() { return 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 = SDL_RequestAndroidPermissionCallback;
 
using RequestAndroidPermissionCB = std::function<void (const char *, bool)>;
 
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(
        std::move(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)
 
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_ */