Use SDL_bool instead an int return code in the SDL API

Most SDL functions used to indicate success or failure using an int return code. These functions have been changed to return SDL_bool. Here is a coccinelle patch to change code that previously compared the return value to 0 and changes it to a boolean test: @ bool_return_type @ identifier func =~ "^(SDL_AddEventWatch|SDL_AddHintCallback|SDL_AddSurfaceAlternateImage|SDL_AddVulkanRenderSemaphores|SDL_BindAudioStream|SDL_BindAudioStreams|SDL_BlitSurface|SDL_BlitSurface9Grid|SDL_BlitSurfaceScaled|SDL_BlitSurfaceTiled|SDL_BlitSurfaceTiledWithScale|SDL_BlitSurfaceUnchecked|SDL_BlitSurfaceUncheckedScaled|SDL_CaptureMouse|SDL_ClearAudioStream|SDL_ClearClipboardData|SDL_ClearComposition|SDL_ClearError|SDL_ClearProperty|SDL_ClearSurface|SDL_CloseIO|SDL_CloseStorage|SDL_ConvertAudioSamples|SDL_ConvertEventToRenderCoordinates|SDL_ConvertPixels|SDL_ConvertPixelsAndColorspace|SDL_CopyFile|SDL_CopyProperties|SDL_CopyStorageFile|SDL_CreateDirectory|SDL_CreateStorageDirectory|SDL_CreateWindowAndRenderer|SDL_DateTimeToTime|SDL_DestroyWindowSurface|SDL_DetachVirtualJoystick|SDL_DisableScreenSaver|SDL_EnableScreenSaver|SDL_EnumerateDirectory|SDL_EnumerateProperties|SDL_EnumerateStorageDirectory|SDL_FillSurfaceRect|SDL_FillSurfaceRects|SDL_FlashWindow|SDL_FlipSurface|SDL_FlushAudioStream|SDL_FlushRenderer|SDL_GL_DestroyContext|SDL_GL_GetAttribute|SDL_GL_GetSwapInterval|SDL_GL_LoadLibrary|SDL_GL_MakeCurrent|SDL_GL_SetAttribute|SDL_GL_SetSwapInterval|SDL_GL_SwapWindow|SDL_GetAudioDeviceFormat|SDL_GetAudioStreamFormat|SDL_GetCameraFormat|SDL_GetClosestFullscreenDisplayMode|SDL_GetCurrentRenderOutputSize|SDL_GetCurrentTime|SDL_GetDXGIOutputInfo|SDL_GetDateTimeLocalePreferences|SDL_GetDisplayBounds|SDL_GetDisplayUsableBounds|SDL_GetGDKDefaultUser|SDL_GetGDKTaskQueue|SDL_GetGamepadSensorData|SDL_GetGamepadTouchpadFinger|SDL_GetHapticEffectStatus|SDL_GetJoystickBall|SDL_GetMasksForPixelFormat|SDL_GetPathInfo|SDL_GetRectUnion|SDL_GetRectUnionFloat|SDL_GetRenderClipRect|SDL_GetRenderColorScale|SDL_GetRenderDrawBlendMode|SDL_GetRenderDrawColor|SDL_GetRenderDrawColorFloat|SDL_GetRenderLogicalPresentation|SDL_GetRenderLogicalPresentationRect|SDL_GetRenderOutputSize|SDL_GetRenderSafeArea|SDL_GetRenderScale|SDL_GetRenderVSync|SDL_GetRenderViewport|SDL_GetSensorData|SDL_GetStorageFileSize|SDL_GetStoragePathInfo|SDL_GetSurfaceAlphaMod|SDL_GetSurfaceBlendMode|SDL_GetSurfaceClipRect|SDL_GetSurfaceColorKey|SDL_GetSurfaceColorMod|SDL_GetTextInputArea|SDL_GetTextureAlphaMod|SDL_GetTextureAlphaModFloat|SDL_GetTextureBlendMode|SDL_GetTextureColorMod|SDL_GetTextureColorModFloat|SDL_GetTextureScaleMode|SDL_GetTextureSize|SDL_GetWindowAspectRatio|SDL_GetWindowBordersSize|SDL_GetWindowMaximumSize|SDL_GetWindowMinimumSize|SDL_GetWindowPosition|SDL_GetWindowRelativeMouseMode|SDL_GetWindowSafeArea|SDL_GetWindowSize|SDL_GetWindowSizeInPixels|SDL_GetWindowSurfaceVSync|SDL_HideCursor|SDL_HideWindow|SDL_Init|SDL_InitHapticRumble|SDL_InitSubSystem|SDL_LoadWAV|SDL_LoadWAV_IO|SDL_LockAudioStream|SDL_LockProperties|SDL_LockSurface|SDL_LockTexture|SDL_LockTextureToSurface|SDL_MaximizeWindow|SDL_MinimizeWindow|SDL_MixAudio|SDL_OpenURL|SDL_OutOfMemory|SDL_PauseAudioDevice|SDL_PauseAudioStreamDevice|SDL_PauseHaptic|SDL_PlayHapticRumble|SDL_PremultiplyAlpha|SDL_PremultiplySurfaceAlpha|SDL_PushEvent|SDL_PutAudioStreamData|SDL_RaiseWindow|SDL_ReadStorageFile|SDL_ReadSurfacePixel|SDL_ReadSurfacePixelFloat|SDL_RegisterApp|SDL_ReloadGamepadMappings|SDL_RemovePath|SDL_RemoveStoragePath|SDL_RemoveTimer|SDL_RenamePath|SDL_RenameStoragePath|SDL_RenderClear|SDL_RenderCoordinatesFromWindow|SDL_RenderCoordinatesToWindow|SDL_RenderFillRect|SDL_RenderFillRects|SDL_RenderGeometry|SDL_RenderGeometryRaw|SDL_RenderLine|SDL_RenderLines|SDL_RenderPoint|SDL_RenderPoints|SDL_RenderPresent|SDL_RenderRect|SDL_RenderRects|SDL_RenderTexture|SDL_RenderTexture9Grid|SDL_RenderTextureRotated|SDL_RenderTextureTiled|SDL_RequestAndroidPermission|SDL_RestoreWindow|SDL_ResumeAudioDevice|SDL_ResumeAudioStreamDevice|SDL_ResumeHaptic|SDL_RumbleGamepad|SDL_RumbleGamepadTriggers|SDL_RumbleJoystick|SDL_RumbleJoystickTriggers|SDL_RunHapticEffect|SDL_SaveBMP|SDL_SaveBMP_IO|SDL_SendAndroidMessage|SDL_SendGamepadEffect|SDL_SendJoystickEffect|SDL_SendJoystickVirtualSensorData|SDL_SetAppMetadata|SDL_SetAppMetadataProperty|SDL_SetAudioDeviceGain|SDL_SetAudioPostmixCallback|SDL_SetAudioStreamFormat|SDL_SetAudioStreamFrequencyRatio|SDL_SetAudioStreamGain|SDL_SetAudioStreamGetCallback|SDL_SetAudioStreamInputChannelMap|SDL_SetAudioStreamOutputChannelMap|SDL_SetAudioStreamPutCallback|SDL_SetBooleanProperty|SDL_SetClipboardData|SDL_SetClipboardText|SDL_SetCursor|SDL_SetFloatProperty|SDL_SetGamepadLED|SDL_SetGamepadMapping|SDL_SetGamepadPlayerIndex|SDL_SetGamepadSensorEnabled|SDL_SetHapticAutocenter|SDL_SetHapticGain|SDL_SetJoystickLED|SDL_SetJoystickPlayerIndex|SDL_SetJoystickVirtualAxis|SDL_SetJoystickVirtualBall|SDL_SetJoystickVirtualButton|SDL_SetJoystickVirtualHat|SDL_SetJoystickVirtualTouchpad|SDL_SetLinuxThreadPriority|SDL_SetLinuxThreadPriorityAndPolicy|SDL_SetLogPriorityPrefix|SDL_SetMemoryFunctions|SDL_SetNumberProperty|SDL_SetPaletteColors|SDL_SetPointerProperty|SDL_SetPointerPropertyWithCleanup|SDL_SetPrimarySelectionText|SDL_SetRenderClipRect|SDL_SetRenderColorScale|SDL_SetRenderDrawBlendMode|SDL_SetRenderDrawColor|SDL_SetRenderDrawColorFloat|SDL_SetRenderLogicalPresentation|SDL_SetRenderScale|SDL_SetRenderTarget|SDL_SetRenderVSync|SDL_SetRenderViewport|SDL_SetScancodeName|SDL_SetStringProperty|SDL_SetSurfaceAlphaMod|SDL_SetSurfaceBlendMode|SDL_SetSurfaceColorKey|SDL_SetSurfaceColorMod|SDL_SetSurfaceColorspace|SDL_SetSurfacePalette|SDL_SetSurfaceRLE|SDL_SetTLS|SDL_SetTextInputArea|SDL_SetTextureAlphaMod|SDL_SetTextureAlphaModFloat|SDL_SetTextureBlendMode|SDL_SetTextureColorMod|SDL_SetTextureColorModFloat|SDL_SetTextureScaleMode|SDL_SetThreadPriority|SDL_SetWindowAlwaysOnTop|SDL_SetWindowAspectRatio|SDL_SetWindowBordered|SDL_SetWindowFocusable|SDL_SetWindowFullscreen|SDL_SetWindowFullscreenMode|SDL_SetWindowHitTest|SDL_SetWindowIcon|SDL_SetWindowKeyboardGrab|SDL_SetWindowMaximumSize|SDL_SetWindowMinimumSize|SDL_SetWindowModalFor|SDL_SetWindowMouseGrab|SDL_SetWindowMouseRect|SDL_SetWindowOpacity|SDL_SetWindowPosition|SDL_SetWindowRelativeMouseMode|SDL_SetWindowResizable|SDL_SetWindowShape|SDL_SetWindowSize|SDL_SetWindowSurfaceVSync|SDL_SetWindowTitle|SDL_SetiOSAnimationCallback|SDL_ShowAndroidToast|SDL_ShowCursor|SDL_ShowMessageBox|SDL_ShowSimpleMessageBox|SDL_ShowWindow|SDL_ShowWindowSystemMenu|SDL_StartTextInput|SDL_StartTextInputWithProperties|SDL_StopHapticEffect|SDL_StopHapticEffects|SDL_StopHapticRumble|SDL_StopTextInput|SDL_SyncWindow|SDL_TimeToDateTime|SDL_TryLockMutex|SDL_TryLockRWLockForReading|SDL_TryLockRWLockForWriting|SDL_TryWaitSemaphore|SDL_UnlockAudioStream|SDL_UpdateHapticEffect|SDL_UpdateNVTexture|SDL_UpdateTexture|SDL_UpdateWindowSurface|SDL_UpdateWindowSurfaceRects|SDL_UpdateYUVTexture|SDL_Vulkan_CreateSurface|SDL_Vulkan_LoadLibrary|SDL_WaitConditionTimeout|SDL_WaitSemaphoreTimeout|SDL_WarpMouseGlobal|SDL_WriteStorageFile|SDL_WriteSurfacePixel|SDL_WriteSurfacePixelFloat)$"; @@ ( func( ... ) - == 0 | - func( + !func( ... ) - < 0 | - func( + !func( ... ) - != 0 | - func( + !func( ... ) - == -1 )
2025-10-06 09:56:26 +00:00 · 2024-08-22 17:33:49 -07:00
parent d9a5ed75b9
commit 9ff3446f03
726 changed files with 11062 additions and 11472 deletions
--- a/src/haptic/SDL_haptic.c
+++ b/src/haptic/SDL_haptic.c
@@ -26,22 +26,15 @@

 static SDL_Haptic *SDL_haptics = NULL;

-#define CHECK_HAPTIC_MAGIC(haptic, retval)                  \
+#define CHECK_HAPTIC_MAGIC(haptic, result)                  \
    if (!SDL_ObjectValid(haptic, SDL_OBJECT_TYPE_HAPTIC)) { \
        SDL_InvalidParamError("haptic");                    \
-        return retval;                                      \
+        return result;                                      \
    }

-int SDL_InitHaptics(void)
+bool SDL_InitHaptics(void)
 {
-    int status;
-
-    status = SDL_SYS_HapticInit();
-    if (status >= 0) {
-        status = 0;
-    }
-
-    return status;
+    return SDL_SYS_HapticInit();
 }

 static bool SDL_GetHapticIndex(SDL_HapticID instance_id, int *driver_index)
@@ -137,7 +130,7 @@ SDL_Haptic *SDL_OpenHaptic(SDL_HapticID instance_id)
    SDL_SetObjectValid(haptic, SDL_OBJECT_TYPE_HAPTIC, true);
    haptic->instance_id = instance_id;
    haptic->rumble_id = -1;
-    if (SDL_SYS_HapticOpen(haptic) < 0) {
+    if (!SDL_SYS_HapticOpen(haptic)) {
        SDL_free(haptic);
        return NULL;
    }
@@ -247,7 +240,7 @@ SDL_Haptic *SDL_OpenHapticFromJoystick(SDL_Joystick *joystick)

        // Joystick must be haptic
        if (SDL_IsGamepad(SDL_GetJoystickID(joystick)) ||
-            SDL_SYS_JoystickIsHaptic(joystick) <= 0) {
+            !SDL_SYS_JoystickIsHaptic(joystick)) {
            SDL_SetError("Haptic: Joystick isn't a haptic device.");
            SDL_UnlockJoysticks();
            return NULL;
@@ -276,7 +269,7 @@ SDL_Haptic *SDL_OpenHapticFromJoystick(SDL_Joystick *joystick)
         * This function should fill in the instance ID and name.
         */
        haptic->rumble_id = -1;
-        if (SDL_SYS_HapticOpenFromJoystick(haptic, joystick) < 0) {
+        if (!SDL_SYS_HapticOpenFromJoystick(haptic, joystick)) {
            SDL_SetError("Haptic: SDL_SYS_HapticOpenFromJoystick failed.");
            SDL_free(haptic);
            SDL_UnlockJoysticks();
@@ -398,12 +391,14 @@ int SDL_CreateHapticEffect(SDL_Haptic *haptic, const SDL_HapticEffect *effect)
    CHECK_HAPTIC_MAGIC(haptic, -1);

    if (!effect) {
-        return SDL_InvalidParamError("effect");
+        SDL_InvalidParamError("effect");
+        return -1;
    }

    // Check to see if effect is supported
    if (SDL_HapticEffectSupported(haptic, effect) == false) {
-        return SDL_SetError("Haptic: Effect not supported by haptic device.");
+        SDL_SetError("Haptic: Effect not supported by haptic device.");
+        return -1;
    }

    // See if there's a free slot
@@ -411,7 +406,7 @@ int SDL_CreateHapticEffect(SDL_Haptic *haptic, const SDL_HapticEffect *effect)
        if (haptic->effects[i].hweffect == NULL) {

            // Now let the backend create the real effect
-            if (SDL_SYS_HapticNewEffect(haptic, &haptic->effects[i], effect) < 0) {
+            if (!SDL_SYS_HapticNewEffect(haptic, &haptic->effects[i], effect)) {
                return -1; // Backend failed to create effect
            }

@@ -421,24 +416,25 @@ int SDL_CreateHapticEffect(SDL_Haptic *haptic, const SDL_HapticEffect *effect)
        }
    }

-    return SDL_SetError("Haptic: Device has no free space left.");
+    SDL_SetError("Haptic: Device has no free space left.");
+    return -1;
 }

-static int ValidEffect(SDL_Haptic *haptic, int effect)
+static bool ValidEffect(SDL_Haptic *haptic, int effect)
 {
    if ((effect < 0) || (effect >= haptic->neffects)) {
        SDL_SetError("Haptic: Invalid effect identifier.");
-        return 0;
+        return false;
    }
-    return 1;
+    return true;
 }

-int SDL_UpdateHapticEffect(SDL_Haptic *haptic, int effect, const SDL_HapticEffect *data)
+SDL_bool SDL_UpdateHapticEffect(SDL_Haptic *haptic, int effect, const SDL_HapticEffect *data)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!ValidEffect(haptic, effect)) {
-        return -1;
+        return false;
    }

    if (!data) {
@@ -451,46 +447,45 @@ int SDL_UpdateHapticEffect(SDL_Haptic *haptic, int effect, const SDL_HapticEffec
    }

    // Updates the effect
-    if (SDL_SYS_HapticUpdateEffect(haptic, &haptic->effects[effect], data) <
-        0) {
-        return -1;
+    if (!SDL_SYS_HapticUpdateEffect(haptic, &haptic->effects[effect], data)) {
+        return false;
    }

    SDL_memcpy(&haptic->effects[effect].effect, data,
               sizeof(SDL_HapticEffect));
-    return 0;
+    return true;
 }

-int SDL_RunHapticEffect(SDL_Haptic *haptic, int effect, Uint32 iterations)
+SDL_bool SDL_RunHapticEffect(SDL_Haptic *haptic, int effect, Uint32 iterations)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!ValidEffect(haptic, effect)) {
-        return -1;
+        return false;
    }

    // Run the effect
-    if (SDL_SYS_HapticRunEffect(haptic, &haptic->effects[effect], iterations) < 0) {
-        return -1;
+    if (!SDL_SYS_HapticRunEffect(haptic, &haptic->effects[effect], iterations)) {
+        return false;
    }

-    return 0;
+    return true;
 }

-int SDL_StopHapticEffect(SDL_Haptic *haptic, int effect)
+SDL_bool SDL_StopHapticEffect(SDL_Haptic *haptic, int effect)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!ValidEffect(haptic, effect)) {
-        return -1;
+        return false;
    }

    // Stop the effect
-    if (SDL_SYS_HapticStopEffect(haptic, &haptic->effects[effect]) < 0) {
-        return -1;
+    if (!SDL_SYS_HapticStopEffect(haptic, &haptic->effects[effect])) {
+        return false;
    }

-    return 0;
+    return true;
 }

 void SDL_DestroyHapticEffect(SDL_Haptic *haptic, int effect)
@@ -509,27 +504,29 @@ void SDL_DestroyHapticEffect(SDL_Haptic *haptic, int effect)
    SDL_SYS_HapticDestroyEffect(haptic, &haptic->effects[effect]);
 }

-int SDL_GetHapticEffectStatus(SDL_Haptic *haptic, int effect)
+SDL_bool SDL_GetHapticEffectStatus(SDL_Haptic *haptic, int effect)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!ValidEffect(haptic, effect)) {
-        return -1;
+        return false;
    }

    if (!(haptic->supported & SDL_HAPTIC_STATUS)) {
        return SDL_SetError("Haptic: Device does not support status queries.");
    }

+    SDL_ClearError();
+
    return SDL_SYS_HapticGetEffectStatus(haptic, &haptic->effects[effect]);
 }

-int SDL_SetHapticGain(SDL_Haptic *haptic, int gain)
+SDL_bool SDL_SetHapticGain(SDL_Haptic *haptic, int gain)
 {
    const char *env;
    int real_gain, max_gain;

-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!(haptic->supported & SDL_HAPTIC_GAIN)) {
        return SDL_SetError("Haptic: Device does not support setting gain.");
@@ -557,16 +554,12 @@ int SDL_SetHapticGain(SDL_Haptic *haptic, int gain)
        real_gain = gain;
    }

-    if (SDL_SYS_HapticSetGain(haptic, real_gain) < 0) {
-        return -1;
-    }
-
-    return 0;
+    return SDL_SYS_HapticSetGain(haptic, real_gain);
 }

-int SDL_SetHapticAutocenter(SDL_Haptic *haptic, int autocenter)
+SDL_bool SDL_SetHapticAutocenter(SDL_Haptic *haptic, int autocenter)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!(haptic->supported & SDL_HAPTIC_AUTOCENTER)) {
        return SDL_SetError("Haptic: Device does not support setting autocenter.");
@@ -576,16 +569,12 @@ int SDL_SetHapticAutocenter(SDL_Haptic *haptic, int autocenter)
        return SDL_SetError("Haptic: Autocenter must be between 0 and 100.");
    }

-    if (SDL_SYS_HapticSetAutocenter(haptic, autocenter) < 0) {
-        return -1;
-    }
-
-    return 0;
+    return SDL_SYS_HapticSetAutocenter(haptic, autocenter);
 }

-int SDL_PauseHaptic(SDL_Haptic *haptic)
+SDL_bool SDL_PauseHaptic(SDL_Haptic *haptic)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!(haptic->supported & SDL_HAPTIC_PAUSE)) {
        return SDL_SetError("Haptic: Device does not support setting pausing.");
@@ -594,20 +583,20 @@ int SDL_PauseHaptic(SDL_Haptic *haptic)
    return SDL_SYS_HapticPause(haptic);
 }

-int SDL_ResumeHaptic(SDL_Haptic *haptic)
+SDL_bool SDL_ResumeHaptic(SDL_Haptic *haptic)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (!(haptic->supported & SDL_HAPTIC_PAUSE)) {
-        return 0; // Not going to be paused, so we pretend it's unpaused.
+        return true; // Not going to be paused, so we pretend it's unpaused.
    }

-    return SDL_SYS_HapticUnpause(haptic);
+    return SDL_SYS_HapticResume(haptic);
 }

-int SDL_StopHapticEffects(SDL_Haptic *haptic)
+SDL_bool SDL_StopHapticEffects(SDL_Haptic *haptic)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    return SDL_SYS_HapticStopAll(haptic);
 }
@@ -620,15 +609,15 @@ SDL_bool SDL_HapticRumbleSupported(SDL_Haptic *haptic)
    return (haptic->supported & (SDL_HAPTIC_SINE | SDL_HAPTIC_LEFTRIGHT)) != 0;
 }

-int SDL_InitHapticRumble(SDL_Haptic *haptic)
+SDL_bool SDL_InitHapticRumble(SDL_Haptic *haptic)
 {
    SDL_HapticEffect *efx = &haptic->rumble_effect;

-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    // Already allocated.
    if (haptic->rumble_id >= 0) {
-        return 0;
+        return true;
    }

    SDL_zerop(efx);
@@ -651,17 +640,17 @@ int SDL_InitHapticRumble(SDL_Haptic *haptic)

    haptic->rumble_id = SDL_CreateHapticEffect(haptic, &haptic->rumble_effect);
    if (haptic->rumble_id >= 0) {
-        return 0;
+        return true;
    }
-    return -1;
+    return false;
 }

-int SDL_PlayHapticRumble(SDL_Haptic *haptic, float strength, Uint32 length)
+SDL_bool SDL_PlayHapticRumble(SDL_Haptic *haptic, float strength, Uint32 length)
 {
    SDL_HapticEffect *efx;
    Sint16 magnitude;

-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (haptic->rumble_id < 0) {
        return SDL_SetError("Haptic: Rumble effect not initialized on haptic device");
@@ -686,16 +675,16 @@ int SDL_PlayHapticRumble(SDL_Haptic *haptic, float strength, Uint32 length)
        SDL_assert(!"This should have been caught elsewhere");
    }

-    if (SDL_UpdateHapticEffect(haptic, haptic->rumble_id, &haptic->rumble_effect) < 0) {
-        return -1;
+    if (!SDL_UpdateHapticEffect(haptic, haptic->rumble_id, &haptic->rumble_effect)) {
+        return false;
    }

    return SDL_RunHapticEffect(haptic, haptic->rumble_id, 1);
 }

-int SDL_StopHapticRumble(SDL_Haptic *haptic)
+SDL_bool SDL_StopHapticRumble(SDL_Haptic *haptic)
 {
-    CHECK_HAPTIC_MAGIC(haptic, -1);
+    CHECK_HAPTIC_MAGIC(haptic, false);

    if (haptic->rumble_id < 0) {
        return SDL_SetError("Haptic: Rumble effect not initialized on haptic device");
--- a/src/haptic/SDL_haptic_c.h
+++ b/src/haptic/SDL_haptic_c.h
@@ -22,7 +22,7 @@
 #ifndef SDL_haptic_c_h_
 #define SDL_haptic_c_h_

-extern int SDL_InitHaptics(void);
+extern bool SDL_InitHaptics(void);
 extern void SDL_QuitHaptics(void);

 #endif // SDL_haptic_c_h_
--- a/src/haptic/SDL_syshaptic.h
+++ b/src/haptic/SDL_syshaptic.h
@@ -62,7 +62,7 @@ struct SDL_Haptic
 *
 * Returns number of devices on success, -1 on error.
 */
-extern int SDL_SYS_HapticInit(void);
+extern bool SDL_SYS_HapticInit(void);

 // Function to return the number of haptic devices plugged in right now
 extern int SDL_SYS_NumHaptics(void);
@@ -80,15 +80,13 @@ extern const char *SDL_SYS_HapticName(int index);
 /*
 * Opens the haptic device for usage.  The haptic device should have
 * the index value set previously.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticOpen(SDL_Haptic *haptic);
+extern bool SDL_SYS_HapticOpen(SDL_Haptic *haptic);

 /*
 * Returns the index of the haptic core pointer or -1 if none is found.
 */
-int SDL_SYS_HapticMouse(void);
+extern int SDL_SYS_HapticMouse(void);

 /*
 * Checks to see if the joystick has haptic capabilities.
@@ -98,10 +96,8 @@ extern bool SDL_SYS_JoystickIsHaptic(SDL_Joystick *joystick);
 /*
 * Opens the haptic device for usage using the same device as
 * the joystick.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic,
+extern bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic,
                                          SDL_Joystick *joystick);
 /*
 * Checks to see if haptic device and joystick device are the same.
@@ -124,39 +120,31 @@ extern void SDL_SYS_HapticQuit(void);
 /*
 * Creates a new haptic effect on the haptic device using base
 * as a template for the effect.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
-                                   struct haptic_effect *effect,
-                                   const SDL_HapticEffect *base);
+extern bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
+                                    struct haptic_effect *effect,
+                                    const SDL_HapticEffect *base);

 /*
 * Updates the haptic effect on the haptic device using data
 * as a template.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
-                                      struct haptic_effect *effect,
-                                      const SDL_HapticEffect *data);
+extern bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
+                                       struct haptic_effect *effect,
+                                       const SDL_HapticEffect *data);

 /*
 * Runs the effect on the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic,
-                                   struct haptic_effect *effect,
-                                   Uint32 iterations);
+extern bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic,
+                                    struct haptic_effect *effect,
+                                    Uint32 iterations);

 /*
 * Stops the effect on the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic,
-                                    struct haptic_effect *effect);
+extern bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic,
+                                     struct haptic_effect *effect);

 /*
 * Cleanups up the effect on the haptic device.
@@ -175,38 +163,28 @@ extern int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic,

 /*
 * Sets the global gain of the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain);
+extern bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain);

 /*
 * Sets the autocenter feature of the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter);
+extern bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter);

 /*
 * Pauses the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticPause(SDL_Haptic *haptic);
+extern bool SDL_SYS_HapticPause(SDL_Haptic *haptic);

 /*
 * Unpauses the haptic device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticUnpause(SDL_Haptic *haptic);
+extern bool SDL_SYS_HapticResume(SDL_Haptic *haptic);

 /*
 * Stops all the currently playing haptic effects on the device.
- *
- * Returns 0 on success, -1 on error.
 */
-extern int SDL_SYS_HapticStopAll(SDL_Haptic *haptic);
+extern bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic);

 // Ends C function definitions when using C++
 #ifdef __cplusplus
--- a/src/haptic/android/SDL_syshaptic.c
+++ b/src/haptic/android/SDL_syshaptic.c
@@ -39,11 +39,11 @@ static SDL_hapticlist_item *SDL_hapticlist = NULL;
 static SDL_hapticlist_item *SDL_hapticlist_tail = NULL;
 static int numhaptics = 0;

-int SDL_SYS_HapticInit(void)
+bool SDL_SYS_HapticInit(void)
 {
    Android_JNI_PollHapticDevices();

-    return numhaptics;
+    return true;
 }

 int SDL_SYS_NumHaptics(void)
@@ -128,9 +128,9 @@ static SDL_hapticlist_item *OpenHapticByInstanceID(SDL_Haptic *haptic, SDL_Hapti
    return OpenHaptic(haptic, HapticByInstanceID(instance_id));
 }

-int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
+bool SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 {
-    return OpenHapticByInstanceID(haptic, haptic->instance_id) == NULL ? -1 : 0;
+    return OpenHapticByInstanceID(haptic, haptic->instance_id) != NULL;
 }

 int SDL_SYS_HapticMouse(void)
@@ -143,7 +143,7 @@ bool SDL_SYS_JoystickIsHaptic(SDL_Joystick *joystick)
    return false;
 }

-int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    return SDL_Unsupported();
 }
@@ -179,20 +179,20 @@ void SDL_SYS_HapticQuit(void)
 #endif
 }

-int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
                            struct haptic_effect *effect, const SDL_HapticEffect *base)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
                               struct haptic_effect *effect,
                               const SDL_HapticEffect *data)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            Uint32 iterations)
 {
    float large = effect->effect.leftright.large_magnitude / 32767.0f;
@@ -201,13 +201,13 @@ int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
    float total = (large * 0.6f) + (small * 0.4f);

    Android_JNI_HapticRun(((SDL_hapticlist_item *)haptic->hwdata)->device_id, total, effect->effect.leftright.length);
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    Android_JNI_HapticStop(((SDL_hapticlist_item *)haptic->hwdata)->device_id);
-    return 0;
+    return true;
 }

 void SDL_SYS_HapticDestroyEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
@@ -219,37 +219,37 @@ int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic, struct haptic_effect *effe
    return 0;
 }

-int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticPause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticPause(SDL_Haptic *haptic)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticResume(SDL_Haptic *haptic)
 {
-    return 0;
+    return true;
 }

-int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
 {
-    return 0;
+    return true;
 }

-int Android_AddHaptic(int device_id, const char *name)
+bool Android_AddHaptic(int device_id, const char *name)
 {
    SDL_hapticlist_item *item;
    item = (SDL_hapticlist_item *)SDL_calloc(1, sizeof(SDL_hapticlist_item));
    if (!item) {
-        return -1;
+        return false;
    }

    item->instance_id = SDL_GetNextObjectID();
@@ -257,7 +257,7 @@ int Android_AddHaptic(int device_id, const char *name)
    item->name = SDL_strdup(name);
    if (!item->name) {
        SDL_free(item);
-        return -1;
+        return false;
    }

    if (!SDL_hapticlist_tail) {
@@ -268,10 +268,10 @@ int Android_AddHaptic(int device_id, const char *name)
    }

    ++numhaptics;
-    return numhaptics;
+    return true;
 }

-int Android_RemoveHaptic(int device_id)
+bool Android_RemoveHaptic(int device_id)
 {
    SDL_hapticlist_item *item;
    SDL_hapticlist_item *prev = NULL;
@@ -279,7 +279,7 @@ int Android_RemoveHaptic(int device_id)
    for (item = SDL_hapticlist; item; item = item->next) {
        // found it, remove it.
        if (device_id == item->device_id) {
-            const int retval = item->haptic ? 0 : -1;
+            const bool result = item->haptic ? true : false;

            if (prev) {
                prev->next = item->next;
@@ -297,11 +297,11 @@ int Android_RemoveHaptic(int device_id)

            SDL_free(item->name);
            SDL_free(item);
-            return retval;
+            return result;
        }
        prev = item;
    }
-    return -1;
+    return false;
 }

 #endif // SDL_HAPTIC_ANDROID
--- a/src/haptic/android/SDL_syshaptic_c.h
+++ b/src/haptic/android/SDL_syshaptic_c.h
@@ -22,7 +22,7 @@

 #ifdef SDL_HAPTIC_ANDROID

-extern int Android_AddHaptic(int device_id, const char *name);
-extern int Android_RemoveHaptic(int device_id);
+extern bool Android_AddHaptic(int device_id, const char *name);
+extern bool Android_RemoveHaptic(int device_id);

 #endif // SDL_HAPTIC_ANDROID
--- a/src/haptic/darwin/SDL_syshaptic.c
+++ b/src/haptic/darwin/SDL_syshaptic.c
@@ -77,7 +77,7 @@ struct haptic_hweffect
 * Prototypes.
 */
 static void SDL_SYS_HapticFreeFFEFFECT(FFEFFECT *effect, int type);
-static int HIDGetDeviceProduct(io_service_t dev, char *name);
+static bool HIDGetDeviceProduct(io_service_t dev, char *name);

 static SDL_hapticlist_item *SDL_hapticlist = NULL;
 static SDL_hapticlist_item *SDL_hapticlist_tail = NULL;
@@ -141,7 +141,7 @@ static const char *FFStrError(unsigned int err)
 /*
 * Initializes the haptic subsystem.
 */
-int SDL_SYS_HapticInit(void)
+bool SDL_SYS_HapticInit(void)
 {
    IOReturn result;
    io_iterator_t iter;
@@ -167,7 +167,7 @@ int SDL_SYS_HapticInit(void)
    // IOServiceGetMatchingServices consumes dictionary.

    if (!IOIteratorIsValid(iter)) { // No iterator.
-        return 0;
+        return true;
    }

    while ((device = IOIteratorNext(iter)) != IO_OBJECT_NULL) {
@@ -177,7 +177,7 @@ int SDL_SYS_HapticInit(void)
    }
    IOObjectRelease(iter);

-    return numhaptics;
+    return true;
 }

 int SDL_SYS_NumHaptics(void)
@@ -213,7 +213,7 @@ static SDL_hapticlist_item *HapticByInstanceID(SDL_HapticID instance_id)
    return NULL;
 }

-int MacHaptic_MaybeAddDevice(io_object_t device)
+bool MacHaptic_MaybeAddDevice(io_object_t device)
 {
    IOReturn result;
    CFMutableDictionaryRef hidProperties;
@@ -221,19 +221,19 @@ int MacHaptic_MaybeAddDevice(io_object_t device)
    SDL_hapticlist_item *item;

    if (numhaptics == -1) {
-        return -1; // not initialized. We'll pick these up on enumeration if we init later.
+        return false; // not initialized. We'll pick these up on enumeration if we init later.
    }

    // Check for force feedback.
    if (FFIsForceFeedback(device) != FF_OK) {
-        return -1;
+        return false;
    }

    // Make sure we don't already have it
    for (item = SDL_hapticlist; item; item = item->next) {
        if (IOObjectIsEqualTo((io_object_t)item->dev, device)) {
            // Already added
-            return -1;
+            return false;
        }
    }

@@ -285,22 +285,22 @@ int MacHaptic_MaybeAddDevice(io_object_t device)
    // Device has been added.
    ++numhaptics;

-    return numhaptics;
+    return true;
 }

-int MacHaptic_MaybeRemoveDevice(io_object_t device)
+bool MacHaptic_MaybeRemoveDevice(io_object_t device)
 {
    SDL_hapticlist_item *item;
    SDL_hapticlist_item *prev = NULL;

    if (numhaptics == -1) {
-        return -1; // not initialized. ignore this.
+        return false; // not initialized. ignore this.
    }

    for (item = SDL_hapticlist; item; item = item->next) {
        // found it, remove it.
        if (IOObjectIsEqualTo((io_object_t)item->dev, device)) {
-            const int retval = item->haptic ? 0 : -1;
+            bool result = item->haptic ? true : false;

            if (prev) {
                prev->next = item->next;
@@ -318,12 +318,12 @@ int MacHaptic_MaybeRemoveDevice(io_object_t device)

            IOObjectRelease(item->dev);
            SDL_free(item);
-            return retval;
+            return result;
        }
        prev = item;
    }

-    return -1;
+    return false;
 }

 SDL_HapticID SDL_SYS_HapticInstanceID(int index)
@@ -352,7 +352,7 @@ const char *SDL_SYS_HapticName(int index)
 /*
 * Gets the device's product name.
 */
-static int HIDGetDeviceProduct(io_service_t dev, char *name)
+static bool HIDGetDeviceProduct(io_service_t dev, char *name)
 {
    CFMutableDictionaryRef hidProperties, usbProperties;
    io_registry_entry_t parent1, parent2;
@@ -412,7 +412,7 @@ static int HIDGetDeviceProduct(io_service_t dev, char *name)
        return SDL_SetError("Haptic: Error getting registry entries.");
    }

-    return 0;
+    return true;
 }

 #define FF_TEST(ff, s)                    \
@@ -421,7 +421,7 @@ static int HIDGetDeviceProduct(io_service_t dev, char *name)
 /*
 * Gets supported features.
 */
-static unsigned int GetSupportedFeatures(SDL_Haptic *haptic)
+static bool GetSupportedFeatures(SDL_Haptic *haptic)
 {
    HRESULT ret;
    FFDeviceObjectReference device;
@@ -486,16 +486,15 @@ static unsigned int GetSupportedFeatures(SDL_Haptic *haptic)
    supported |= SDL_HAPTIC_STATUS | SDL_HAPTIC_PAUSE;

    haptic->supported = supported;
-    return 0;
+    return true;
 }

 /*
 * Opens the haptic device from the file descriptor.
 */
-static int SDL_SYS_HapticOpenFromService(SDL_Haptic *haptic, io_service_t service)
+static bool SDL_SYS_HapticOpenFromService(SDL_Haptic *haptic, io_service_t service)
 {
    HRESULT ret;
-    int ret2;

    // Allocate the hwdata
    haptic->hwdata = (struct haptic_hwdata *) SDL_calloc(1, sizeof(*haptic->hwdata));
@@ -511,8 +510,7 @@ static int SDL_SYS_HapticOpenFromService(SDL_Haptic *haptic, io_service_t servic
    }

    // Get supported features.
-    ret2 = GetSupportedFeatures(haptic);
-    if (ret2 < 0) {
+    if (!GetSupportedFeatures(haptic)) {
        goto open_err;
    }

@@ -541,7 +539,7 @@ static int SDL_SYS_HapticOpenFromService(SDL_Haptic *haptic, io_service_t servic
    SDL_memset(haptic->effects, 0,
               sizeof(struct haptic_effect) * haptic->neffects);

-    return 0;
+    return true;

    // Error handling
 open_err:
@@ -551,13 +549,13 @@ creat_err:
        SDL_free(haptic->hwdata);
        haptic->hwdata = NULL;
    }
-    return -1;
+    return false;
 }

 /*
 * Opens a haptic device for usage.
 */
-int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
+bool SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 {
    SDL_hapticlist_item *item;
    item = HapticByInstanceID(haptic->instance_id);
@@ -581,7 +579,7 @@ int SDL_SYS_HapticMouse(void)
        ++device_index;
    }

-    return -1;
+    return 0;
 }

 /*
@@ -620,13 +618,13 @@ bool SDL_SYS_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
 /*
 * Opens a SDL_Haptic from a SDL_Joystick.
 */
-int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
 #ifdef SDL_JOYSTICK_IOKIT
    SDL_hapticlist_item *item;

    if (joystick->driver != &SDL_DARWIN_JoystickDriver) {
-        return -1;
+        return false;
    }
    for (item = SDL_hapticlist; item; item = item->next) {
        if (IOObjectIsEqualTo((io_object_t)item->dev,
@@ -642,7 +640,7 @@ int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)

    return SDL_SYS_HapticOpenFromService(haptic, joystick->hwdata->ffservice);
 #else
-    return -1;
+    return false;
 #endif
 }

@@ -709,7 +707,7 @@ static DWORD FFGetTriggerButton(Uint16 button)
 /*
 * Sets the direction.
 */
-static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir, int naxes)
+static bool SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir, int naxes)
 {
    LONG *rglDir;

@@ -717,13 +715,13 @@ static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir
    if (naxes == 0) {
        effect->dwFlags |= FFEFF_SPHERICAL; // Set as default.
        effect->rglDirection = NULL;
-        return 0;
+        return true;
    }

    // Has axes.
    rglDir = SDL_malloc(sizeof(LONG) * naxes);
    if (!rglDir) {
-        return -1;
+        return false;
    }
    SDL_memset(rglDir, 0, sizeof(LONG) * naxes);
    effect->rglDirection = rglDir;
@@ -732,7 +730,7 @@ static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir
    case SDL_HAPTIC_POLAR:
        effect->dwFlags |= FFEFF_POLAR;
        rglDir[0] = dir->dir[0];
-        return 0;
+        return true;
    case SDL_HAPTIC_CARTESIAN:
        effect->dwFlags |= FFEFF_CARTESIAN;
        rglDir[0] = dir->dir[0];
@@ -742,7 +740,7 @@ static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir
        if (naxes > 2) {
            rglDir[2] = dir->dir[2];
        }
-        return 0;
+        return true;
    case SDL_HAPTIC_SPHERICAL:
        effect->dwFlags |= FFEFF_SPHERICAL;
        rglDir[0] = dir->dir[0];
@@ -752,11 +750,11 @@ static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir
        if (naxes > 2) {
            rglDir[2] = dir->dir[2];
        }
-        return 0;
+        return true;
    case SDL_HAPTIC_STEERING_AXIS:
        effect->dwFlags |= FFEFF_CARTESIAN;
        rglDir[0] = 0;
-        return 0;
+        return true;

    default:
        return SDL_SetError("Haptic: Unknown direction type.");
@@ -770,7 +768,7 @@ static int SDL_SYS_SetDirection(FFEFFECT *effect, const SDL_HapticDirection *dir
 /*
 * Creates the FFEFFECT from a SDL_HapticEffect.
 */
-static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_HapticEffect *src)
+static bool SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_HapticEffect *src)
 {
    int i;
    FFCONSTANTFORCE *constant = NULL;
@@ -796,7 +794,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
    // Envelope.
    envelope = SDL_calloc(1, sizeof(FFENVELOPE));
    if (!envelope) {
-        return -1;
+        return false;
    }
    dest->lpEnvelope = envelope;
    envelope->dwSize = sizeof(FFENVELOPE); // Always should be this.
@@ -810,7 +808,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
    if (dest->cAxes > 0) {
        axes = SDL_malloc(sizeof(DWORD) * dest->cAxes);
        if (!axes) {
-            return -1;
+            return false;
        }
        axes[0] = haptic->hwdata->axes[0]; // Always at least one axis.
        if (dest->cAxes > 1) {
@@ -828,7 +826,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        hap_constant = &src->constant;
        constant = SDL_calloc(1, sizeof(FFCONSTANTFORCE));
        if (!constant) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -843,8 +841,8 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        dest->dwStartDelay = hap_constant->delay * 1000; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -868,7 +866,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        hap_periodic = &src->periodic;
        periodic = SDL_calloc(1, sizeof(FFPERIODIC));
        if (!periodic) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -887,8 +885,8 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        dest->dwStartDelay = hap_periodic->delay * 1000; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -912,7 +910,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        if (dest->cAxes > 0) {
            condition = SDL_calloc(dest->cAxes, sizeof(FFCONDITION));
            if (!condition) {
-                return -1;
+                return false;
            }

            // Specifics
@@ -940,8 +938,8 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        dest->dwStartDelay = hap_condition->delay * 1000; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope - Not actually supported by most CONDITION implementations.
@@ -954,7 +952,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        hap_ramp = &src->ramp;
        ramp = SDL_calloc(1, sizeof(FFRAMPFORCE));
        if (!ramp) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -970,8 +968,8 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        dest->dwStartDelay = hap_ramp->delay * 1000; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -991,7 +989,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        hap_custom = &src->custom;
        custom = SDL_calloc(1, sizeof(FFCUSTOMFORCE));
        if (!custom) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -1013,9 +1011,8 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        dest->dwStartDelay = hap_custom->delay * 1000; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes) <
-            0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -1035,7 +1032,7 @@ static int SDL_SYS_ToFFEFFECT(SDL_Haptic *haptic, FFEFFECT *dest, const SDL_Hapt
        return SDL_SetError("Haptic: Unknown effect type.");
    }

-    return 0;
+    return true;
 }

 /*
@@ -1114,7 +1111,7 @@ SDL_SYS_HapticEffectType(Uint16 type)
 /*
 * Creates a new haptic effect.
 */
-int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            const SDL_HapticEffect *base)
 {
    HRESULT ret;
@@ -1134,7 +1131,7 @@ int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
    }

    // Get the effect.
-    if (SDL_SYS_ToFFEFFECT(haptic, &effect->hweffect->effect, base) < 0) {
+    if (!SDL_SYS_ToFFEFFECT(haptic, &effect->hweffect->effect, base)) {
        goto err_effectdone;
    }

@@ -1147,20 +1144,20 @@ int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
        goto err_effectdone;
    }

-    return 0;
+    return true;

 err_effectdone:
    SDL_SYS_HapticFreeFFEFFECT(&effect->hweffect->effect, base->type);
 err_hweffect:
    SDL_free(effect->hweffect);
    effect->hweffect = NULL;
-    return -1;
+    return false;
 }

 /*
 * Updates an effect.
 */
-int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
                               struct haptic_effect *effect,
                               const SDL_HapticEffect *data)
 {
@@ -1170,7 +1167,7 @@ int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,

    // Get the effect.
    SDL_memset(&temp, 0, sizeof(FFEFFECT));
-    if (SDL_SYS_ToFFEFFECT(haptic, &temp, data) < 0) {
+    if (!SDL_SYS_ToFFEFFECT(haptic, &temp, data)) {
        goto err_update;
    }

@@ -1194,17 +1191,17 @@ int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
    SDL_SYS_HapticFreeFFEFFECT(&effect->hweffect->effect, data->type);
    SDL_memcpy(&effect->hweffect->effect, &temp, sizeof(FFEFFECT));

-    return 0;
+    return true;

 err_update:
    SDL_SYS_HapticFreeFFEFFECT(&temp, data->type);
-    return -1;
+    return false;
 }

 /*
 * Runs an effect.
 */
-int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            Uint32 iterations)
 {
    HRESULT ret;
@@ -1224,13 +1221,13 @@ int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
 * Stops an effect.
 */
-int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    HRESULT ret;

@@ -1240,7 +1237,7 @@ int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
                            FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
@@ -1272,20 +1269,20 @@ int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic,

    ret = FFEffectGetEffectStatus(effect->hweffect->ref, &status);
    if (ret != FF_OK) {
-        return SDL_SetError("Haptic: Unable to get effect status: %s.",
-                     FFStrError(ret));
+        SDL_SetError("Haptic: Unable to get effect status: %s.", FFStrError(ret));
+        return -1;
    }

    if (status == 0) {
-        return false;
+        return 0;
    }
-    return true; // Assume it's playing or emulated.
+    return 1; // Assume it's playing or emulated.
 }

 /*
 * Sets the gain.
 */
-int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    HRESULT ret;
    Uint32 val;
@@ -1297,13 +1294,13 @@ int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
        return SDL_SetError("Haptic: Error setting gain: %s.", FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
 * Sets the autocentering.
 */
-int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    HRESULT ret;
    Uint32 val;
@@ -1322,13 +1319,13 @@ int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
                            FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
 * Pauses the device.
 */
-int SDL_SYS_HapticPause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticPause(SDL_Haptic *haptic)
 {
    HRESULT ret;

@@ -1338,29 +1335,29 @@ int SDL_SYS_HapticPause(SDL_Haptic *haptic)
        return SDL_SetError("Haptic: Error pausing device: %s.", FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
 * Unpauses the device.
 */
-int SDL_SYS_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticResume(SDL_Haptic *haptic)
 {
    HRESULT ret;

    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
                                           FFSFFC_CONTINUE);
    if (ret != FF_OK) {
-        return SDL_SetError("Haptic: Error pausing device: %s.", FFStrError(ret));
+        return SDL_SetError("Haptic: Error resuming device: %s.", FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 /*
 * Stops all currently playing effects.
 */
-int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
 {
    HRESULT ret;

@@ -1370,7 +1367,7 @@ int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
        return SDL_SetError("Haptic: Error stopping device: %s.", FFStrError(ret));
    }

-    return 0;
+    return true;
 }

 #endif // SDL_HAPTIC_IOKIT
--- a/src/haptic/darwin/SDL_syshaptic_c.h
+++ b/src/haptic/darwin/SDL_syshaptic_c.h
@@ -25,5 +25,5 @@
 #define kIOMainPortDefault kIOMasterPortDefault
 #endif

-extern int MacHaptic_MaybeAddDevice(io_object_t device);
-extern int MacHaptic_MaybeRemoveDevice(io_object_t device);
+extern bool MacHaptic_MaybeAddDevice(io_object_t device);
+extern bool MacHaptic_MaybeRemoveDevice(io_object_t device);
--- a/src/haptic/dummy/SDL_syshaptic.c
+++ b/src/haptic/dummy/SDL_syshaptic.c
@@ -24,14 +24,14 @@

 #include "../SDL_syshaptic.h"

-static int SDL_SYS_LogicError(void)
+static bool SDL_SYS_LogicError(void)
 {
    return SDL_SetError("Logic error: No haptic devices available.");
 }

-int SDL_SYS_HapticInit(void)
+bool SDL_SYS_HapticInit(void)
 {
-    return 0;
+    return true;
 }

 int SDL_SYS_NumHaptics(void)
@@ -51,7 +51,7 @@ const char *SDL_SYS_HapticName(int index)
    return NULL;
 }

-int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
+bool SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 {
    return SDL_SYS_LogicError();
 }
@@ -66,7 +66,7 @@ bool SDL_SYS_JoystickIsHaptic(SDL_Joystick *joystick)
    return false;
 }

-int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    return SDL_SYS_LogicError();
 }
@@ -86,26 +86,26 @@ void SDL_SYS_HapticQuit(void)
    return;
 }

-int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic,
                            struct haptic_effect *effect, const SDL_HapticEffect *base)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
                               struct haptic_effect *effect,
                               const SDL_HapticEffect *data)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            Uint32 iterations)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    return SDL_SYS_LogicError();
 }
@@ -119,30 +119,31 @@ void SDL_SYS_HapticDestroyEffect(SDL_Haptic *haptic, struct haptic_effect *effec
 int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic,
                                  struct haptic_effect *effect)
 {
-    return SDL_SYS_LogicError();
+    SDL_SYS_LogicError();
+    return -1;
 }

-int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticPause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticPause(SDL_Haptic *haptic)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticResume(SDL_Haptic *haptic)
 {
    return SDL_SYS_LogicError();
 }

-int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
 {
    return SDL_SYS_LogicError();
 }
--- a/src/haptic/linux/SDL_syshaptic.c
+++ b/src/haptic/linux/SDL_syshaptic.c
@@ -38,9 +38,9 @@

 #define MAX_HAPTICS 32 // It's doubtful someone has more then 32 evdev

-static int MaybeAddDevice(const char *path);
+static bool MaybeAddDevice(const char *path);
 #ifdef SDL_USE_LIBUDEV
-static int MaybeRemoveDevice(const char *path);
+static bool MaybeRemoveDevice(const char *path);
 static void haptic_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath);
 #endif // SDL_USE_LIBUDEV

@@ -85,16 +85,15 @@ static int numhaptics = 0;
 * Test whether a device has haptic properties.
 * Returns available properties or 0 if there are none.
 */
-static int EV_IsHaptic(int fd)
+static Uint32 EV_IsHaptic(int fd)
 {
-    unsigned int ret;
    unsigned long features[1 + FF_MAX / sizeof(unsigned long)];
+    Uint32 ret = 0;

    // Ask device for what it has.
-    ret = 0;
    if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(features)), features) < 0) {
-        return SDL_SetError("Haptic: Unable to get device's features: %s",
-                            strerror(errno));
+        SDL_SetError("Haptic: Unable to get device's features: %s", strerror(errno));
+        return 0;
    }

    // Convert supported features to SDL_HAPTIC platform-neutral features.
@@ -121,27 +120,27 @@ static int EV_IsHaptic(int fd)
 /*
 * Tests whether a device is a mouse or not.
 */
-static int EV_IsMouse(int fd)
+static bool EV_IsMouse(int fd)
 {
    unsigned long argp[40];

    // Ask for supported features.
    if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(argp)), argp) < 0) {
-        return -1;
+        return false;
    }

    // Currently we only test for BTN_MOUSE which can give fake positives.
    if (test_bit(BTN_MOUSE, argp) != 0) {
-        return 1;
+        return true;
    }

-    return 0;
+    return true;
 }

 /*
 * Initializes the haptic subsystem by finding available devices.
 */
-int SDL_SYS_HapticInit(void)
+bool SDL_SYS_HapticInit(void)
 {
    const char joydev_pattern[] = "/dev/input/event%d";
    char path[PATH_MAX];
@@ -158,11 +157,11 @@ int SDL_SYS_HapticInit(void)
    }

 #ifdef SDL_USE_LIBUDEV
-    if (SDL_UDEV_Init() < 0) {
+    if (!SDL_UDEV_Init()) {
        return SDL_SetError("Could not initialize UDEV");
    }

-    if (SDL_UDEV_AddCallback(haptic_udev_callback) < 0) {
+    if (!SDL_UDEV_AddCallback(haptic_udev_callback)) {
        SDL_UDEV_Quit();
        return SDL_SetError("Could not setup haptic <-> udev callback");
    }
@@ -171,7 +170,7 @@ int SDL_SYS_HapticInit(void)
    SDL_UDEV_Scan();
 #endif // SDL_USE_LIBUDEV

-    return numhaptics;
+    return true;
 }

 int SDL_SYS_NumHaptics(void)
@@ -229,34 +228,34 @@ static void haptic_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class,
 }
 #endif // SDL_USE_LIBUDEV

-static int MaybeAddDevice(const char *path)
+static bool MaybeAddDevice(const char *path)
 {
    struct stat sb;
    int fd;
-    int success;
+    Uint32 supported;
    SDL_hapticlist_item *item;

    if (!path) {
-        return -1;
+        return false;
    }

    // try to open
    fd = open(path, O_RDWR | O_CLOEXEC, 0);
    if (fd < 0) {
-        return -1;
+        return false;
    }

    // get file status
    if (fstat(fd, &sb) != 0) {
        close(fd);
-        return -1;
+        return false;
    }

    // check for duplicates
    for (item = SDL_hapticlist; item; item = item->next) {
        if (item->dev_num == sb.st_rdev) {
            close(fd);
-            return -1; // duplicate.
+            return false; // duplicate.
        }
    }

@@ -265,22 +264,22 @@ static int MaybeAddDevice(const char *path)
 #endif

    // see if it works
-    success = EV_IsHaptic(fd);
+    supported = EV_IsHaptic(fd);
    close(fd);
-    if (success <= 0) {
-        return -1;
+    if (!supported) {
+        return false;
    }

    item = (SDL_hapticlist_item *)SDL_calloc(1, sizeof(SDL_hapticlist_item));
    if (!item) {
-        return -1;
+        return false;
    }

    item->instance_id = SDL_GetNextObjectID();
    item->fname = SDL_strdup(path);
    if (!item->fname) {
        SDL_free(item);
-        return -1;
+        return false;
    }

    item->dev_num = sb.st_rdev;
@@ -297,23 +296,23 @@ static int MaybeAddDevice(const char *path)

    // !!! TODO: Send a haptic add event?

-    return numhaptics;
+    return true;
 }

 #ifdef SDL_USE_LIBUDEV
-static int MaybeRemoveDevice(const char *path)
+static bool MaybeRemoveDevice(const char *path)
 {
    SDL_hapticlist_item *item;
    SDL_hapticlist_item *prev = NULL;

    if (!path) {
-        return -1;
+        return false;
    }

    for (item = SDL_hapticlist; item; item = item->next) {
        // found it, remove it.
        if (SDL_strcmp(path, item->fname) == 0) {
-            const int retval = item->haptic ? 0 : -1;
+            const bool result = item->haptic ? true : false;

            if (prev) {
                prev->next = item->next;
@@ -331,12 +330,12 @@ static int MaybeRemoveDevice(const char *path)

            SDL_free(item->fname);
            SDL_free(item);
-            return retval;
+            return result;
        }
        prev = item;
    }

-    return -1;
+    return false;
 }
 #endif // SDL_USE_LIBUDEV

@@ -399,7 +398,7 @@ const char *SDL_SYS_HapticName(int index)
 /*
 * Opens the haptic device from the file descriptor.
 */
-static int SDL_SYS_HapticOpenFromFD(SDL_Haptic *haptic, int fd)
+static bool SDL_SYS_HapticOpenFromFD(SDL_Haptic *haptic, int fd)
 {
    // Allocate the hwdata
    haptic->hwdata = (struct haptic_hwdata *)
@@ -429,7 +428,7 @@ static int SDL_SYS_HapticOpenFromFD(SDL_Haptic *haptic, int fd)
    SDL_memset(haptic->effects, 0,
               sizeof(struct haptic_effect) * haptic->neffects);

-    return 0;
+    return true;

    // Error handling
 open_err:
@@ -438,16 +437,15 @@ open_err:
        SDL_free(haptic->hwdata);
        haptic->hwdata = NULL;
    }
-    return -1;
+    return false;
 }

 /*
 * Opens a haptic device for usage.
 */
-int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
+bool SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 {
    int fd;
-    int ret;
    SDL_hapticlist_item *item;

    item = HapticByInstanceID(haptic->instance_id);
@@ -459,14 +457,14 @@ int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
    }

    // Try to create the haptic.
-    ret = SDL_SYS_HapticOpenFromFD(haptic, fd); // Already closes on error.
-    if (ret < 0) {
-        return -1;
+    if (!SDL_SYS_HapticOpenFromFD(haptic, fd)) {
+        // Already closes on error.
+        return false;
    }

    // Set the fname.
    haptic->hwdata->fname = SDL_strdup(item->fname);
-    return 0;
+    return true;
 }

 /*
@@ -541,18 +539,17 @@ bool SDL_SYS_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
 /*
 * Opens a SDL_Haptic from a SDL_Joystick.
 */
-int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
 #ifdef SDL_JOYSTICK_LINUX
    int fd;
-    int ret;
    SDL_hapticlist_item *item;
    const char *name;

    SDL_AssertJoysticksLocked();

    if (joystick->driver != &SDL_LINUX_JoystickDriver) {
-        return -1;
+        return false;
    }
    // Find the joystick in the haptic list.
    for (item = SDL_hapticlist; item; item = item->next) {
@@ -567,9 +564,9 @@ int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
        return SDL_SetError("Haptic: Unable to open %s: %s",
                            joystick->hwdata->fname, strerror(errno));
    }
-    ret = SDL_SYS_HapticOpenFromFD(haptic, fd); // Already closes on error.
-    if (ret < 0) {
-        return -1;
+    if (!SDL_SYS_HapticOpenFromFD(haptic, fd)) {
+        // Already closes on error.
+        return false;
    }

    haptic->hwdata->fname = SDL_strdup(joystick->hwdata->fname);
@@ -578,9 +575,9 @@ int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
    if (name) {
        haptic->name = SDL_strdup(name);
    }
-    return 0;
+    return true;
 #else
-    return -1;
+    return false;
 #endif
 }

@@ -658,7 +655,7 @@ static Uint16 SDL_SYS_ToButton(Uint16 button)
 /*
 * Initializes the ff_effect usable direction from a SDL_HapticDirection.
 */
-static int SDL_SYS_ToDirection(Uint16 *dest, const SDL_HapticDirection *src)
+static bool SDL_SYS_ToDirection(Uint16 *dest, const SDL_HapticDirection *src)
 {
    Uint32 tmp;

@@ -711,7 +708,7 @@ static int SDL_SYS_ToDirection(Uint16 *dest, const SDL_HapticDirection *src)
        return SDL_SetError("Haptic: Unsupported direction type.");
    }

-    return 0;
+    return true;
 }

 #define CLAMP(x) (((x) > 32767) ? 32767 : x)
@@ -719,7 +716,7 @@ static int SDL_SYS_ToDirection(Uint16 *dest, const SDL_HapticDirection *src)
 * Initializes the Linux effect struct from a haptic_effect.
 * Values above 32767 (for unsigned) are unspecified so we must clamp.
 */
-static int SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *src)
+static bool SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *src)
 {
    const SDL_HapticConstant *constant;
    const SDL_HapticPeriodic *periodic;
@@ -736,8 +733,8 @@ static int SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *sr

        // Header
        dest->type = FF_CONSTANT;
-        if (SDL_SYS_ToDirection(&dest->direction, &constant->direction) == -1) {
-            return -1;
+        if (!SDL_SYS_ToDirection(&dest->direction, &constant->direction)) {
+            return false;
        }

        // Replay
@@ -770,8 +767,8 @@ static int SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *sr

        // Header
        dest->type = FF_PERIODIC;
-        if (SDL_SYS_ToDirection(&dest->direction, &periodic->direction) == -1) {
-            return -1;
+        if (!SDL_SYS_ToDirection(&dest->direction, &periodic->direction)) {
+            return false;
        }

        // Replay
@@ -864,8 +861,8 @@ static int SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *sr

        // Header
        dest->type = FF_RAMP;
-        if (SDL_SYS_ToDirection(&dest->direction, &ramp->direction) == -1) {
-            return -1;
+        if (!SDL_SYS_ToDirection(&dest->direction, &ramp->direction)) {
+            return false;
        }

        // Replay
@@ -912,13 +909,13 @@ static int SDL_SYS_ToFFEffect(struct ff_effect *dest, const SDL_HapticEffect *sr
        return SDL_SetError("Haptic: Unknown effect type.");
    }

-    return 0;
+    return true;
 }

 /*
 * Creates a new haptic effect.
 */
-int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            const SDL_HapticEffect *base)
 {
    struct ff_effect *linux_effect;
@@ -927,12 +924,12 @@ int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
    effect->hweffect = (struct haptic_hweffect *)
        SDL_calloc(1, sizeof(struct haptic_hweffect));
    if (!effect->hweffect) {
-        return -1;
+        return false;
    }

    // Prepare the ff_effect
    linux_effect = &effect->hweffect->effect;
-    if (SDL_SYS_ToFFEffect(linux_effect, base) != 0) {
+    if (!SDL_SYS_ToFFEffect(linux_effect, base)) {
        goto new_effect_err;
    }
    linux_effect->id = -1; // Have the kernel give it an id
@@ -944,12 +941,12 @@ int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
        goto new_effect_err;
    }

-    return 0;
+    return true;

 new_effect_err:
    SDL_free(effect->hweffect);
    effect->hweffect = NULL;
-    return -1;
+    return false;
 }

 /*
@@ -958,15 +955,15 @@ new_effect_err:
 * Note: Dynamically updating the direction can in some cases force
 * the effect to restart and run once.
 */
-int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
+bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
                               struct haptic_effect *effect,
                               const SDL_HapticEffect *data)
 {
    struct ff_effect linux_effect;

    // Create the new effect
-    if (SDL_SYS_ToFFEffect(&linux_effect, data) != 0) {
-        return -1;
+    if (!SDL_SYS_ToFFEffect(&linux_effect, data)) {
+        return false;
    }
    linux_effect.id = effect->hweffect->effect.id;

@@ -980,13 +977,13 @@ int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic,
    SDL_memcpy(&effect->hweffect->effect, &linux_effect,
               sizeof(struct ff_effect));

-    return effect->hweffect->effect.id;
+    return true;
 }

 /*
 * Runs an effect.
 */
-int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            Uint32 iterations)
 {
    struct input_event run;
@@ -1001,13 +998,13 @@ int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
        return SDL_SetError("Haptic: Unable to run the effect: %s", strerror(errno));
    }

-    return 0;
+    return true;
 }

 /*
 * Stops an effect.
 */
-int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    struct input_event stop;

@@ -1020,7 +1017,7 @@ int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
                            strerror(errno));
    }

-    return 0;
+    return true;
 }

 /*
@@ -1050,19 +1047,21 @@ int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic,
    ie.code = effect->hweffect->effect.id;

    if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) {
-        return SDL_SetError("Haptic: Error getting device status.");
+        SDL_SetError("Haptic: Error getting device status.");
+        return -1;
    }

-    return 0;
+    return 1;
 #endif

+    SDL_Unsupported();
    return -1;
 }

 /*
 * Sets the gain.
 */
-int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    struct input_event ie;

@@ -1074,13 +1073,13 @@ int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
        return SDL_SetError("Haptic: Error setting gain: %s", strerror(errno));
    }

-    return 0;
+    return true;
 }

 /*
 * Sets the autocentering.
 */
-int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    struct input_event ie;

@@ -1092,29 +1091,29 @@ int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
        return SDL_SetError("Haptic: Error setting autocenter: %s", strerror(errno));
    }

-    return 0;
+    return true;
 }

 /*
 * Pausing is not supported atm by linux.
 */
-int SDL_SYS_HapticPause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticPause(SDL_Haptic *haptic)
 {
-    return -1;
+    return SDL_Unsupported();
 }

 /*
 * Unpausing is not supported atm by linux.
 */
-int SDL_SYS_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticResume(SDL_Haptic *haptic)
 {
-    return -1;
+    return SDL_Unsupported();
 }

 /*
 * Stops all the currently playing effects.
 */
-int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
 {
    int i, ret;

@@ -1127,7 +1126,7 @@ int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
            }
        }
    }
-    return 0;
+    return true;
 }

 #endif // SDL_HAPTIC_LINUX
--- a/src/haptic/windows/SDL_dinputhaptic.c
+++ b/src/haptic/windows/SDL_dinputhaptic.c
@@ -46,7 +46,7 @@ static LPDIRECTINPUT8 dinput = NULL;
 /*
 * Like SDL_SetError but for DX error codes.
 */
-static int DI_SetError(const char *str, HRESULT err)
+static bool DI_SetError(const char *str, HRESULT err)
 {
    return SDL_SetError("Haptic error %s", str);
 }
@@ -61,7 +61,7 @@ static BOOL CALLBACK EnumHapticsCallback(const DIDEVICEINSTANCE *pdidInstance, V
    return DIENUM_CONTINUE; // continue enumerating
 }

-int SDL_DINPUT_HapticInit(void)
+bool SDL_DINPUT_HapticInit(void)
 {
    HRESULT ret;
    HINSTANCE instance;
@@ -73,7 +73,7 @@ int SDL_DINPUT_HapticInit(void)

    if (!SDL_GetHintBoolean(SDL_HINT_JOYSTICK_DIRECTINPUT, true)) {
        // In some environments, IDirectInput8_Initialize / _EnumDevices can take a minute even with no controllers.
-        return 0;
+        return true;
    }

    ret = WIN_CoInitialize();
@@ -122,10 +122,10 @@ int SDL_DINPUT_HapticInit(void)
        }
    }

-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
+bool SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
 {
    HRESULT ret;
    LPDIRECTINPUTDEVICE8 device;
@@ -134,13 +134,13 @@ int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
    SDL_hapticlist_item *item = NULL;

    if (!dinput) {
-        return -1; // not initialized. We'll pick these up on enumeration if we init later.
+        return false; // not initialized. We'll pick these up on enumeration if we init later.
    }

    // Make sure we don't already have it
    for (item = SDL_hapticlist; item; item = item->next) {
        if (SDL_memcmp(&item->instance, pdidInstance, sizeof(*pdidInstance)) == 0) {
-            return -1; // Already added
+            return false; // Already added
        }
    }

@@ -148,7 +148,7 @@ int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
    ret = IDirectInput8_CreateDevice(dinput, &pdidInstance->guidInstance, &device, NULL);
    if (FAILED(ret)) {
        // DI_SetError("Creating DirectInput device",ret);
-        return -1;
+        return false;
    }

    // Get capabilities.
@@ -158,23 +158,23 @@ int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
    IDirectInputDevice8_Release(device);
    if (FAILED(ret)) {
        // DI_SetError("Getting device capabilities",ret);
-        return -1;
+        return false;
    }

    if ((capabilities.dwFlags & needflags) != needflags) {
-        return -1; // not a device we can use.
+        return false; // not a device we can use.
    }

    item = (SDL_hapticlist_item *)SDL_calloc(1, sizeof(SDL_hapticlist_item));
    if (!item) {
-        return -1;
+        return false;
    }

    item->instance_id = SDL_GetNextObjectID();
    item->name = WIN_StringToUTF8(pdidInstance->tszProductName);
    if (!item->name) {
        SDL_free(item);
-        return -1;
+        return false;
    }

    // Copy the instance over, useful for creating devices.
@@ -184,13 +184,13 @@ int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
    return SDL_SYS_AddHapticDevice(item);
 }

-int SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance)
+bool SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance)
 {
    SDL_hapticlist_item *item;
    SDL_hapticlist_item *prev = NULL;

    if (!dinput) {
-        return -1; // not initialized, ignore this.
+        return false; // not initialized, ignore this.
    }

    for (item = SDL_hapticlist; item; item = item->next) {
@@ -200,7 +200,7 @@ int SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance)
        }
        prev = item;
    }
-    return -1;
+    return false;
 }

 /*
@@ -280,7 +280,7 @@ static BOOL CALLBACK DI_EffectCallback(LPCDIEFFECTINFO pei, LPVOID pv)
 *       - Reset actuators.
 *       - Get supported features.
 */
-static int SDL_DINPUT_HapticOpenFromDevice(SDL_Haptic *haptic, LPDIRECTINPUTDEVICE8 device8, bool is_joystick)
+static bool SDL_DINPUT_HapticOpenFromDevice(SDL_Haptic *haptic, LPDIRECTINPUTDEVICE8 device8, bool is_joystick)
 {
    HRESULT ret;
    DIPROPDWORD dipdw;
@@ -288,7 +288,7 @@ static int SDL_DINPUT_HapticOpenFromDevice(SDL_Haptic *haptic, LPDIRECTINPUTDEVI
    // Allocate the hwdata
    haptic->hwdata = (struct haptic_hwdata *)SDL_calloc(1, sizeof(*haptic->hwdata));
    if (!haptic->hwdata) {
-        return -1;
+        return false;
    }

    // We'll use the device8 from now on.
@@ -407,15 +407,15 @@ static int SDL_DINPUT_HapticOpenFromDevice(SDL_Haptic *haptic, LPDIRECTINPUTDEVI
    SDL_memset(haptic->effects, 0,
               sizeof(struct haptic_effect) * haptic->neffects);

-    return 0;
+    return true;

    // Error handling
 acquire_err:
    IDirectInputDevice8_Unacquire(haptic->hwdata->device);
-    return -1;
+    return false;
 }

-int SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item)
+bool SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item)
 {
    HRESULT ret;
    LPDIRECTINPUTDEVICE8 device;
@@ -425,17 +425,17 @@ int SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item)
                                     &device, NULL);
    if (FAILED(ret)) {
        DI_SetError("Creating DirectInput device", ret);
-        return -1;
+        return false;
    }

-    if (SDL_DINPUT_HapticOpenFromDevice(haptic, device, false) < 0) {
+    if (!SDL_DINPUT_HapticOpenFromDevice(haptic, device, false)) {
        IDirectInputDevice8_Release(device);
-        return -1;
+        return false;
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    HRESULT ret;
    DIDEVICEINSTANCE hap_instance, joy_instance;
@@ -447,18 +447,18 @@ int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
    ret = IDirectInputDevice8_GetDeviceInfo(haptic->hwdata->device,
                                            &hap_instance);
    if (FAILED(ret)) {
-        return 0;
+        return false;
    }
    ret = IDirectInputDevice8_GetDeviceInfo(joystick->hwdata->InputDevice,
                                            &joy_instance);
    if (FAILED(ret)) {
-        return 0;
+        return false;
    }

    return WIN_IsEqualGUID(&hap_instance.guidInstance, &joy_instance.guidInstance);
 }

-int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    SDL_hapticlist_item *item;
    HRESULT ret;
@@ -467,7 +467,7 @@ int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick
    joy_instance.dwSize = sizeof(DIDEVICEINSTANCE);
    ret = IDirectInputDevice8_GetDeviceInfo(joystick->hwdata->InputDevice, &joy_instance);
    if (FAILED(ret)) {
-        return -1;
+        return false;
    }

    // Since it comes from a joystick we have to try to match it with a haptic device on our haptic list.
@@ -524,7 +524,7 @@ static DWORD DIGetTriggerButton(Uint16 button)
 /*
 * Sets the direction.
 */
-static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir, int naxes)
+static bool SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir, int naxes)
 {
    LONG *rglDir;

@@ -532,13 +532,13 @@ static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir
    if (naxes == 0) {
        effect->dwFlags |= DIEFF_SPHERICAL; // Set as default.
        effect->rglDirection = NULL;
-        return 0;
+        return true;
    }

    // Has axes.
    rglDir = (LONG *)SDL_malloc(sizeof(LONG) * naxes);
    if (!rglDir) {
-        return -1;
+        return false;
    }
    SDL_memset(rglDir, 0, sizeof(LONG) * naxes);
    effect->rglDirection = rglDir;
@@ -547,7 +547,7 @@ static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir
    case SDL_HAPTIC_POLAR:
        effect->dwFlags |= DIEFF_POLAR;
        rglDir[0] = dir->dir[0];
-        return 0;
+        return true;
    case SDL_HAPTIC_CARTESIAN:
        effect->dwFlags |= DIEFF_CARTESIAN;
        rglDir[0] = dir->dir[0];
@@ -557,7 +557,7 @@ static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir
        if (naxes > 2) {
            rglDir[2] = dir->dir[2];
        }
-        return 0;
+        return true;
    case SDL_HAPTIC_SPHERICAL:
        effect->dwFlags |= DIEFF_SPHERICAL;
        rglDir[0] = dir->dir[0];
@@ -567,11 +567,11 @@ static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir
        if (naxes > 2) {
            rglDir[2] = dir->dir[2];
        }
-        return 0;
+        return true;
    case SDL_HAPTIC_STEERING_AXIS:
        effect->dwFlags |= DIEFF_CARTESIAN;
        rglDir[0] = 0;
-        return 0;
+        return true;

    default:
        return SDL_SetError("Haptic: Unknown direction type.");
@@ -585,7 +585,7 @@ static int SDL_SYS_SetDirection(DIEFFECT *effect, const SDL_HapticDirection *dir
 /*
 * Creates the DIEFFECT from a SDL_HapticEffect.
 */
-static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
+static bool SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
                              const SDL_HapticEffect *src)
 {
    int i;
@@ -612,7 +612,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
    // Envelope.
    envelope = (DIENVELOPE *)SDL_calloc(1, sizeof(DIENVELOPE));
    if (!envelope) {
-        return -1;
+        return false;
    }
    dest->lpEnvelope = envelope;
    envelope->dwSize = sizeof(DIENVELOPE); // Always should be this.
@@ -626,7 +626,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
    if (dest->cAxes > 0) {
        axes = (DWORD *)SDL_malloc(sizeof(DWORD) * dest->cAxes);
        if (!axes) {
-            return -1;
+            return false;
        }
        axes[0] = haptic->hwdata->axes[0]; // Always at least one axis.
        if (dest->cAxes > 1) {
@@ -644,7 +644,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        hap_constant = &src->constant;
        constant = (DICONSTANTFORCE *)SDL_calloc(1, sizeof(DICONSTANTFORCE));
        if (!constant) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -659,8 +659,8 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        dest->dwStartDelay = hap_constant->delay * 1000UL; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -684,7 +684,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        hap_periodic = &src->periodic;
        periodic = (DIPERIODIC *)SDL_calloc(1, sizeof(DIPERIODIC));
        if (!periodic) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -703,8 +703,8 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        dest->dwStartDelay = hap_periodic->delay * 1000UL; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -727,7 +727,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        hap_condition = &src->condition;
        condition = (DICONDITION *)SDL_calloc(dest->cAxes, sizeof(DICONDITION));
        if (!condition) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -753,8 +753,8 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        dest->dwStartDelay = hap_condition->delay * 1000UL; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope - Not actually supported by most CONDITION implementations.
@@ -767,7 +767,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        hap_ramp = &src->ramp;
        ramp = (DIRAMPFORCE *)SDL_calloc(1, sizeof(DIRAMPFORCE));
        if (!ramp) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -783,8 +783,8 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        dest->dwStartDelay = hap_ramp->delay * 1000UL; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -804,7 +804,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        hap_custom = &src->custom;
        custom = (DICUSTOMFORCE *)SDL_calloc(1, sizeof(DICUSTOMFORCE));
        if (!custom) {
-            return -1;
+            return false;
        }

        // Specifics
@@ -825,8 +825,8 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        dest->dwStartDelay = hap_custom->delay * 1000UL; // In microseconds.

        // Direction.
-        if (SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes) < 0) {
-            return -1;
+        if (!SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes)) {
+            return false;
        }

        // Envelope
@@ -846,7 +846,7 @@ static int SDL_SYS_ToDIEFFECT(SDL_Haptic *haptic, DIEFFECT *dest,
        return SDL_SetError("Haptic: Unknown effect type.");
    }

-    return 0;
+    return true;
 }

 /*
@@ -920,7 +920,7 @@ static REFGUID SDL_SYS_HapticEffectType(const SDL_HapticEffect *effect)
        return NULL;
    }
 }
-int SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base)
+bool SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base)
 {
    HRESULT ret;
    REFGUID type = SDL_SYS_HapticEffectType(base);
@@ -930,7 +930,7 @@ int SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
    }

    // Get the effect.
-    if (SDL_SYS_ToDIEFFECT(haptic, &effect->hweffect->effect, base) < 0) {
+    if (!SDL_SYS_ToDIEFFECT(haptic, &effect->hweffect->effect, base)) {
        goto err_effectdone;
    }

@@ -943,14 +943,14 @@ int SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
        goto err_effectdone;
    }

-    return 0;
+    return true;

 err_effectdone:
    SDL_SYS_HapticFreeDIEFFECT(&effect->hweffect->effect, base->type);
-    return -1;
+    return false;
 }

-int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
+bool SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
 {
    HRESULT ret;
    DWORD flags;
@@ -958,7 +958,7 @@ int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effe

    // Get the effect.
    SDL_memset(&temp, 0, sizeof(DIEFFECT));
-    if (SDL_SYS_ToDIEFFECT(haptic, &temp, data) < 0) {
+    if (!SDL_SYS_ToDIEFFECT(haptic, &temp, data)) {
        goto err_update;
    }

@@ -996,14 +996,14 @@ int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effe
    SDL_SYS_HapticFreeDIEFFECT(&effect->hweffect->effect, data->type);
    SDL_memcpy(&effect->hweffect->effect, &temp, sizeof(DIEFFECT));

-    return 0;
+    return true;

 err_update:
    SDL_SYS_HapticFreeDIEFFECT(&temp, data->type);
-    return -1;
+    return false;
 }

-int SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
+bool SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
 {
    HRESULT ret;
    DWORD iter;
@@ -1020,10 +1020,10 @@ int SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
    if (FAILED(ret)) {
        return DI_SetError("Running the effect", ret);
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    HRESULT ret;

@@ -1031,7 +1031,7 @@ int SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect
    if (FAILED(ret)) {
        return DI_SetError("Unable to stop effect", ret);
    }
-    return 0;
+    return true;
 }

 void SDL_DINPUT_HapticDestroyEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
@@ -1061,7 +1061,7 @@ int SDL_DINPUT_HapticGetEffectStatus(SDL_Haptic *haptic, struct haptic_effect *e
    return true;
 }

-int SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    HRESULT ret;
    DIPROPDWORD dipdw;
@@ -1079,10 +1079,10 @@ int SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain)
    if (FAILED(ret)) {
        return DI_SetError("Setting gain", ret);
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    HRESULT ret;
    DIPROPDWORD dipdw;
@@ -1100,10 +1100,10 @@ int SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
    if (FAILED(ret)) {
        return DI_SetError("Setting autocenter", ret);
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticPause(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticPause(SDL_Haptic *haptic)
 {
    HRESULT ret;

@@ -1113,10 +1113,10 @@ int SDL_DINPUT_HapticPause(SDL_Haptic *haptic)
    if (FAILED(ret)) {
        return DI_SetError("Pausing the device", ret);
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticResume(SDL_Haptic *haptic)
 {
    HRESULT ret;

@@ -1126,10 +1126,10 @@ int SDL_DINPUT_HapticUnpause(SDL_Haptic *haptic)
    if (FAILED(ret)) {
        return DI_SetError("Pausing the device", ret);
    }
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
 {
    HRESULT ret;

@@ -1139,7 +1139,7 @@ int SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
    if (FAILED(ret)) {
        return DI_SetError("Stopping the device", ret);
    }
-    return 0;
+    return true;
 }

 #else // !SDL_HAPTIC_DINPUT
@@ -1147,32 +1147,32 @@ int SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
 typedef struct DIDEVICEINSTANCE DIDEVICEINSTANCE;
 typedef struct SDL_hapticlist_item SDL_hapticlist_item;

-int SDL_DINPUT_HapticInit(void)
+bool SDL_DINPUT_HapticInit(void)
 {
-    return 0;
+    return true;
 }

-int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
+bool SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance)
+bool SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item)
+bool SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
-    return SDL_Unsupported();
+    return false;
 }

-int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    return SDL_Unsupported();
 }
@@ -1185,22 +1185,22 @@ void SDL_DINPUT_HapticQuit(void)
 {
 }

-int SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base)
+bool SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
+bool SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
+bool SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    return SDL_Unsupported();
 }
@@ -1211,30 +1211,31 @@ void SDL_DINPUT_HapticDestroyEffect(SDL_Haptic *haptic, struct haptic_effect *ef

 int SDL_DINPUT_HapticGetEffectStatus(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
-    return SDL_Unsupported();
+    SDL_Unsupported();
+    return -1;
 }

-int SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticPause(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticPause(SDL_Haptic *haptic)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticResume(SDL_Haptic *haptic)
 {
    return SDL_Unsupported();
 }

-int SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic)
 {
    return SDL_Unsupported();
 }
--- a/src/haptic/windows/SDL_dinputhaptic_c.h
+++ b/src/haptic/windows/SDL_dinputhaptic_c.h
@@ -27,25 +27,25 @@
 extern "C" {
 #endif

-extern int SDL_DINPUT_HapticInit(void);
-extern int SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance);
-extern int SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance);
-extern int SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item);
-extern int SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick);
-extern int SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick);
+extern bool SDL_DINPUT_HapticInit(void);
+extern bool SDL_DINPUT_HapticMaybeAddDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern bool SDL_DINPUT_HapticMaybeRemoveDevice(const DIDEVICEINSTANCE *pdidInstance);
+extern bool SDL_DINPUT_HapticOpen(SDL_Haptic *haptic, SDL_hapticlist_item *item);
+extern bool SDL_DINPUT_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick);
+extern bool SDL_DINPUT_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick);
 extern void SDL_DINPUT_HapticClose(SDL_Haptic *haptic);
 extern void SDL_DINPUT_HapticQuit(void);
-extern int SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base);
-extern int SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data);
-extern int SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations);
-extern int SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect);
+extern bool SDL_DINPUT_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *base);
+extern bool SDL_DINPUT_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data);
+extern bool SDL_DINPUT_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations);
+extern bool SDL_DINPUT_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect);
 extern void SDL_DINPUT_HapticDestroyEffect(SDL_Haptic *haptic, struct haptic_effect *effect);
 extern int SDL_DINPUT_HapticGetEffectStatus(SDL_Haptic *haptic, struct haptic_effect *effect);
-extern int SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain);
-extern int SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter);
-extern int SDL_DINPUT_HapticPause(SDL_Haptic *haptic);
-extern int SDL_DINPUT_HapticUnpause(SDL_Haptic *haptic);
-extern int SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic);
+extern bool SDL_DINPUT_HapticSetGain(SDL_Haptic *haptic, int gain);
+extern bool SDL_DINPUT_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter);
+extern bool SDL_DINPUT_HapticPause(SDL_Haptic *haptic);
+extern bool SDL_DINPUT_HapticResume(SDL_Haptic *haptic);
+extern bool SDL_DINPUT_HapticStopAll(SDL_Haptic *haptic);

 // Ends C function definitions when using C++
 #ifdef __cplusplus
--- a/src/haptic/windows/SDL_windowshaptic.c
+++ b/src/haptic/windows/SDL_windowshaptic.c
@@ -45,12 +45,12 @@ static int numhaptics = 0;
 /*
 * Initializes the haptic subsystem.
 */
-int SDL_SYS_HapticInit(void)
+bool SDL_SYS_HapticInit(void)
 {
    JoyStick_DeviceData *device;

-    if (SDL_DINPUT_HapticInit() < 0) {
-        return -1;
+    if (!SDL_DINPUT_HapticInit()) {
+        return false;
    }

    /* The joystick subsystem will usually be initialized before haptics,
@@ -62,10 +62,10 @@ int SDL_SYS_HapticInit(void)
        SDL_DINPUT_HapticMaybeAddDevice(&device->dxdevice);
    }

-    return numhaptics;
+    return true;
 }

-int SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item)
+bool SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item)
 {
    if (!SDL_hapticlist_tail) {
        SDL_hapticlist = SDL_hapticlist_tail = item;
@@ -77,12 +77,12 @@ int SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item)
    // Device has been added.
    ++numhaptics;

-    return numhaptics;
+    return true;
 }

-int SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item)
+bool SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item)
 {
-    const int retval = item->haptic ? 0 : -1;
+    const bool result = item->haptic ? true : false;
    if (prev) {
        prev->next = item->next;
    } else {
@@ -95,7 +95,7 @@ int SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *i
    --numhaptics;
    // !!! TODO: Send a haptic remove event?
    SDL_free(item);
-    return retval;
+    return result;
 }

 int SDL_SYS_NumHaptics(void)
@@ -151,7 +151,7 @@ const char *SDL_SYS_HapticName(int index)
 /*
 * Opens a haptic device for usage.
 */
-int SDL_SYS_HapticOpen(SDL_Haptic *haptic)
+bool SDL_SYS_HapticOpen(SDL_Haptic *haptic)
 {
    SDL_hapticlist_item *item = HapticByInstanceID(haptic->instance_id);
    return SDL_DINPUT_HapticOpen(haptic, item);
@@ -205,7 +205,7 @@ bool SDL_SYS_JoystickSameHaptic(SDL_Haptic *haptic, SDL_Joystick *joystick)
 /*
 * Opens a SDL_Haptic from a SDL_Joystick.
 */
-int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
+bool SDL_SYS_HapticOpenFromJoystick(SDL_Haptic *haptic, SDL_Joystick *joystick)
 {
    SDL_assert(joystick->driver == &SDL_WINDOWS_JoystickDriver);

@@ -260,19 +260,19 @@ void SDL_SYS_HapticQuit(void)
 /*
 * Creates a new haptic effect.
 */
-int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
+bool SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
                            const SDL_HapticEffect *base)
 {
-    int result;
+    bool result;

    // Alloc the effect.
    effect->hweffect = (struct haptic_hweffect *) SDL_calloc(1, sizeof(struct haptic_hweffect));
    if (!effect->hweffect) {
-        return -1;
+        return false;
    }

    result = SDL_DINPUT_HapticNewEffect(haptic, effect, base);
-    if (result < 0) {
+    if (!result) {
        SDL_free(effect->hweffect);
        effect->hweffect = NULL;
    }
@@ -282,7 +282,7 @@ int SDL_SYS_HapticNewEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
 /*
 * Updates an effect.
 */
-int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
+bool SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect, const SDL_HapticEffect *data)
 {
    return SDL_DINPUT_HapticUpdateEffect(haptic, effect, data);
 }
@@ -290,7 +290,7 @@ int SDL_SYS_HapticUpdateEffect(SDL_Haptic *haptic, struct haptic_effect *effect,
 /*
 * Runs an effect.
 */
-int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
+bool SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Uint32 iterations)
 {
    return SDL_DINPUT_HapticRunEffect(haptic, effect, iterations);
 }
@@ -298,7 +298,7 @@ int SDL_SYS_HapticRunEffect(SDL_Haptic *haptic, struct haptic_effect *effect, Ui
 /*
 * Stops an effect.
 */
-int SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
+bool SDL_SYS_HapticStopEffect(SDL_Haptic *haptic, struct haptic_effect *effect)
 {
    return SDL_DINPUT_HapticStopEffect(haptic, effect);
 }
@@ -324,7 +324,7 @@ int SDL_SYS_HapticGetEffectStatus(SDL_Haptic *haptic, struct haptic_effect *effe
 /*
 * Sets the gain.
 */
-int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
+bool SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 {
    return SDL_DINPUT_HapticSetGain(haptic, gain);
 }
@@ -332,7 +332,7 @@ int SDL_SYS_HapticSetGain(SDL_Haptic *haptic, int gain)
 /*
 * Sets the autocentering.
 */
-int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
+bool SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 {
    return SDL_DINPUT_HapticSetAutocenter(haptic, autocenter);
 }
@@ -340,7 +340,7 @@ int SDL_SYS_HapticSetAutocenter(SDL_Haptic *haptic, int autocenter)
 /*
 * Pauses the device.
 */
-int SDL_SYS_HapticPause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticPause(SDL_Haptic *haptic)
 {
    return SDL_DINPUT_HapticPause(haptic);
 }
@@ -348,15 +348,15 @@ int SDL_SYS_HapticPause(SDL_Haptic *haptic)
 /*
 * Pauses the device.
 */
-int SDL_SYS_HapticUnpause(SDL_Haptic *haptic)
+bool SDL_SYS_HapticResume(SDL_Haptic *haptic)
 {
-    return SDL_DINPUT_HapticUnpause(haptic);
+    return SDL_DINPUT_HapticResume(haptic);
 }

 /*
 * Stops all the playing effects on the device.
 */
-int SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
+bool SDL_SYS_HapticStopAll(SDL_Haptic *haptic)
 {
    return SDL_DINPUT_HapticStopAll(haptic);
 }
--- a/src/haptic/windows/SDL_windowshaptic_c.h
+++ b/src/haptic/windows/SDL_windowshaptic_c.h
@@ -76,8 +76,8 @@ typedef struct SDL_hapticlist_item

 extern SDL_hapticlist_item *SDL_hapticlist;

-extern int SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item);
-extern int SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item);
+extern bool SDL_SYS_AddHapticDevice(SDL_hapticlist_item *item);
+extern bool SDL_SYS_RemoveHapticDevice(SDL_hapticlist_item *prev, SDL_hapticlist_item *item);

 // Ends C function definitions when using C++
 #ifdef __cplusplus