SDL  2.0
SDL_mouse.c File Reference
#include "../SDL_internal.h"
#include "SDL_assert.h"
#include "SDL_hints.h"
#include "SDL_timer.h"
#include "SDL_events.h"
#include "SDL_events_c.h"
#include "../video/SDL_sysvideo.h"
+ Include dependency graph for SDL_mouse.c:

Go to the source code of this file.

Functions

static int SDL_PrivateSendMouseMotion (SDL_Window *window, SDL_MouseID mouseID, int relative, int x, int y)
 
static void SDL_MouseDoubleClickTimeChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static void SDL_MouseDoubleClickRadiusChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static void SDL_MouseNormalSpeedScaleChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static void SDL_MouseRelativeSpeedScaleChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
static void SDL_TouchMouseEventsChanged (void *userdata, const char *name, const char *oldValue, const char *hint)
 
int SDL_MouseInit (void)
 
void SDL_SetDefaultCursor (SDL_Cursor *cursor)
 
SDL_MouseSDL_GetMouse (void)
 
SDL_WindowSDL_GetMouseFocus (void)
 Get the window which currently has mouse focus. More...
 
void SDL_SetMouseFocus (SDL_Window *window)
 
static SDL_bool SDL_UpdateMouseFocus (SDL_Window *window, int x, int y, Uint32 buttonstate)
 
int SDL_SendMouseMotion (SDL_Window *window, SDL_MouseID mouseID, int relative, int x, int y)
 
static int GetScaledMouseDelta (float scale, int value, float *accum)
 
static SDL_MouseClickStateGetMouseClickState (SDL_Mouse *mouse, Uint8 button)
 
static int SDL_PrivateSendMouseButton (SDL_Window *window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks)
 
int SDL_SendMouseButtonClicks (SDL_Window *window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks)
 
int SDL_SendMouseButton (SDL_Window *window, SDL_MouseID mouseID, Uint8 state, Uint8 button)
 
int SDL_SendMouseWheel (SDL_Window *window, SDL_MouseID mouseID, float x, float y, SDL_MouseWheelDirection direction)
 
void SDL_MouseQuit (void)
 
Uint32 SDL_GetMouseState (int *x, int *y)
 Retrieve the current state of the mouse. More...
 
Uint32 SDL_GetRelativeMouseState (int *x, int *y)
 Retrieve the relative state of the mouse. More...
 
Uint32 SDL_GetGlobalMouseState (int *x, int *y)
 Get the current state of the mouse, in relation to the desktop. More...
 
void SDL_WarpMouseInWindow (SDL_Window *window, int x, int y)
 Moves the mouse to the given position within the window. More...
 
int SDL_WarpMouseGlobal (int x, int y)
 Moves the mouse to the given position in global screen space. More...
 
static SDL_bool ShouldUseRelativeModeWarp (SDL_Mouse *mouse)
 
int SDL_SetRelativeMouseMode (SDL_bool enabled)
 Set relative mouse mode. More...
 
SDL_bool SDL_GetRelativeMouseMode ()
 Query whether relative mouse mode is enabled. More...
 
int SDL_CaptureMouse (SDL_bool enabled)
 Capture the mouse, to track input outside an SDL window. More...
 
SDL_CursorSDL_CreateCursor (const Uint8 *data, const Uint8 *mask, int w, int h, int hot_x, int hot_y)
 Create a cursor, using the specified bitmap data and mask (in MSB format). More...
 
SDL_CursorSDL_CreateColorCursor (SDL_Surface *surface, int hot_x, int hot_y)
 Create a color cursor. More...
 
SDL_CursorSDL_CreateSystemCursor (SDL_SystemCursor id)
 Create a system cursor. More...
 
void SDL_SetCursor (SDL_Cursor *cursor)
 Set the active cursor. More...
 
SDL_CursorSDL_GetCursor (void)
 Return the active cursor. More...
 
SDL_CursorSDL_GetDefaultCursor (void)
 Return the default cursor. More...
 
void SDL_FreeCursor (SDL_Cursor *cursor)
 Frees a cursor created with SDL_CreateCursor() or similar functions. More...
 
int SDL_ShowCursor (int toggle)
 Toggle whether or not the cursor is shown. More...
 

Variables

static SDL_Mouse SDL_mouse
 

Function Documentation

§ GetMouseClickState()

static SDL_MouseClickState* GetMouseClickState ( SDL_Mouse mouse,
Uint8  button 
)
static

Definition at line 421 of file SDL_mouse.c.

References button, SDL_Mouse::clickstate, i, NULL, SDL_Mouse::num_clickstates, SDL_realloc, and SDL_zero.

Referenced by SDL_PrivateSendMouseButton().

422 {
423  if (button >= mouse->num_clickstates) {
424  int i, count = button + 1;
425  SDL_MouseClickState *clickstate = (SDL_MouseClickState *)SDL_realloc(mouse->clickstate, count * sizeof(*mouse->clickstate));
426  if (!clickstate) {
427  return NULL;
428  }
429  mouse->clickstate = clickstate;
430 
431  for (i = mouse->num_clickstates; i < count; ++i) {
432  SDL_zero(mouse->clickstate[i]);
433  }
434  mouse->num_clickstates = count;
435  }
436  return &mouse->clickstate[button];
437 }
SDL_Texture * button
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
SDL_MouseClickState * clickstate
Definition: SDL_mouse_c.h:99
int num_clickstates
Definition: SDL_mouse_c.h:98
#define SDL_realloc
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
#define NULL
Definition: begin_code.h:164

§ GetScaledMouseDelta()

static int GetScaledMouseDelta ( float  scale,
int  value,
float *  accum 
)
static

Definition at line 276 of file SDL_mouse.c.

References SDL_ceil, and SDL_floor.

Referenced by SDL_PrivateSendMouseMotion().

277 {
278  if (scale != 1.0f) {
279  *accum += scale * value;
280  if (*accum >= 0.0f) {
281  value = (int)SDL_floor(*accum);
282  } else {
283  value = (int)SDL_ceil(*accum);
284  }
285  *accum -= value;
286  }
287  return value;
288 }
GLenum GLenum GLenum GLenum GLenum scale
#define SDL_ceil
GLfloat f
#define SDL_floor
GLsizei const GLfloat * value

§ SDL_CaptureMouse()

int SDL_CaptureMouse ( SDL_bool  enabled)

Capture the mouse, to track input outside an SDL window.

Parameters
enabledWhether or not to enable capturing

Capturing enables your app to obtain mouse events globally, instead of just within your window. Not all video targets support this function. When capturing is enabled, the current window will get all mouse events, but unlike relative mode, no change is made to the cursor and it is not restrained to your window.

This function may also deny mouse input to other windows–both those in your application and others on the system–so you should use this function sparingly, and in small bursts. For example, you might want to track the mouse while the user is dragging something, until the user releases a mouse button. It is not recommended that you capture the mouse for long periods of time, such as the entire time your app is running.

While captured, mouse events still report coordinates relative to the current (foreground) window, but those coordinates may be outside the bounds of the window (including negative values). Capturing is only allowed for the foreground window. If the window loses focus while capturing, the capture will be disabled automatically.

While capturing is enabled, the current window will have the SDL_WINDOW_MOUSE_CAPTURE flag set.

Returns
0 on success, or -1 if not supported.

Definition at line 787 of file SDL_mouse.c.

References SDL_Mouse::CaptureMouse, SDL_Window::flags, NULL, SDL_GetKeyboardFocus, SDL_GetMouse(), SDL_SetError, SDL_Unsupported, and SDL_WINDOW_MOUSE_CAPTURE.

Referenced by SDL_MouseQuit().

788 {
789  SDL_Mouse *mouse = SDL_GetMouse();
790  SDL_Window *focusWindow;
791  SDL_bool isCaptured;
792 
793  if (!mouse->CaptureMouse) {
794  return SDL_Unsupported();
795  }
796 
797  focusWindow = SDL_GetKeyboardFocus();
798 
799  isCaptured = focusWindow && (focusWindow->flags & SDL_WINDOW_MOUSE_CAPTURE);
800  if (isCaptured == enabled) {
801  return 0; /* already done! */
802  }
803 
804  if (enabled) {
805  if (!focusWindow) {
806  return SDL_SetError("No window has focus");
807  } else if (mouse->CaptureMouse(focusWindow) == -1) {
808  return -1; /* CaptureMouse() should call SetError */
809  }
810  focusWindow->flags |= SDL_WINDOW_MOUSE_CAPTURE;
811  } else {
812  if (mouse->CaptureMouse(NULL) == -1) {
813  return -1; /* CaptureMouse() should call SetError */
814  }
815  focusWindow->flags &= ~SDL_WINDOW_MOUSE_CAPTURE;
816  }
817 
818  return 0;
819 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define SDL_GetKeyboardFocus
int(* CaptureMouse)(SDL_Window *window)
Definition: SDL_mouse_c.h:70
GLenum GLenum GLsizei const GLuint GLboolean enabled
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:161
#define SDL_SetError
The type used to identify a window.
Definition: SDL_sysvideo.h:73
Uint32 flags
Definition: SDL_sysvideo.h:83
#define SDL_Unsupported()
Definition: SDL_error.h:53

§ SDL_CreateColorCursor()

SDL_Cursor* SDL_CreateColorCursor ( SDL_Surface surface,
int  hot_x,
int  hot_y 
)

Create a color cursor.

See also
SDL_FreeCursor()

Definition at line 871 of file SDL_mouse.c.

References SDL_Mouse::CreateCursor, cursor, SDL_Mouse::cursors, SDL_Surface::format, SDL_PixelFormat::format, SDL_Surface::h, SDL_Cursor::next, NULL, SDL_ConvertSurfaceFormat, SDL_FreeSurface, SDL_GetMouse(), SDL_PIXELFORMAT_ARGB8888, SDL_SetError, and SDL_Surface::w.

Referenced by SDL_CreateCursor().

872 {
873  SDL_Mouse *mouse = SDL_GetMouse();
874  SDL_Surface *temp = NULL;
876 
877  if (!surface) {
878  SDL_SetError("Passed NULL cursor surface");
879  return NULL;
880  }
881 
882  if (!mouse->CreateCursor) {
883  SDL_SetError("Cursors are not currently supported");
884  return NULL;
885  }
886 
887  /* Sanity check the hot spot */
888  if ((hot_x < 0) || (hot_y < 0) ||
889  (hot_x >= surface->w) || (hot_y >= surface->h)) {
890  SDL_SetError("Cursor hot spot doesn't lie within cursor");
891  return NULL;
892  }
893 
894  if (surface->format->format != SDL_PIXELFORMAT_ARGB8888) {
896  if (!temp) {
897  return NULL;
898  }
899  surface = temp;
900  }
901 
902  cursor = mouse->CreateCursor(surface, hot_x, hot_y);
903  if (cursor) {
904  cursor->next = mouse->cursors;
905  mouse->cursors = cursor;
906  }
907 
908  SDL_FreeSurface(temp);
909 
910  return cursor;
911 }
#define SDL_ConvertSurfaceFormat
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_Cursor * cursors
Definition: SDL_mouse_c.h:101
SDL_Cursor *(* CreateCursor)(SDL_Surface *surface, int hot_x, int hot_y)
Definition: SDL_mouse_c.h:46
#define SDL_FreeSurface
SDL_Cursor * cursor
Definition: testwm2.c:40
#define NULL
Definition: begin_code.h:164
SDL_PixelFormat * format
Definition: SDL_surface.h:72
struct SDL_Cursor * next
Definition: SDL_mouse_c.h:32
#define SDL_SetError
int uint32_t uint32_t uint32_t uint32_t uint32_t int drmModeModeInfoPtr mode int uint32_t uint32_t uint32_t uint32_t int32_t hot_x
Definition: SDL_kmsdrmsym.h:55

§ SDL_CreateCursor()

SDL_Cursor* SDL_CreateCursor ( const Uint8 data,
const Uint8 mask,
int  w,
int  h,
int  hot_x,
int  hot_y 
)

Create a cursor, using the specified bitmap data and mask (in MSB format).

The cursor width must be a multiple of 8 bits.

The cursor is created in black and white according to the following:

data mask resulting pixel on screen
0 1 White
1 1 Black
0 0 Transparent
1 0 Inverted color if possible, black if not.
See also
SDL_FreeCursor()

Definition at line 822 of file SDL_mouse.c.

References cursor, NULL, SDL_Surface::pitch, SDL_Surface::pixels, SDL_CreateColorCursor(), SDL_CreateRGBSurface, and SDL_FreeSurface.

824 {
827  int x, y;
828  Uint32 *pixel;
829  Uint8 datab = 0, maskb = 0;
830  const Uint32 black = 0xFF000000;
831  const Uint32 white = 0xFFFFFFFF;
832  const Uint32 transparent = 0x00000000;
833 
834  /* Make sure the width is a multiple of 8 */
835  w = ((w + 7) & ~7);
836 
837  /* Create the surface from a bitmap */
838  surface = SDL_CreateRGBSurface(0, w, h, 32,
839  0x00FF0000,
840  0x0000FF00,
841  0x000000FF,
842  0xFF000000);
843  if (!surface) {
844  return NULL;
845  }
846  for (y = 0; y < h; ++y) {
847  pixel = (Uint32 *) ((Uint8 *) surface->pixels + y * surface->pitch);
848  for (x = 0; x < w; ++x) {
849  if ((x % 8) == 0) {
850  datab = *data++;
851  maskb = *mask++;
852  }
853  if (maskb & 0x80) {
854  *pixel++ = (datab & 0x80) ? black : white;
855  } else {
856  *pixel++ = (datab & 0x80) ? black : transparent;
857  }
858  datab <<= 1;
859  maskb <<= 1;
860  }
861  }
862 
863  cursor = SDL_CreateColorCursor(surface, hot_x, hot_y);
864 
865  SDL_FreeSurface(surface);
866 
867  return cursor;
868 }
SDL_Cursor * SDL_CreateColorCursor(SDL_Surface *surface, int hot_x, int hot_y)
Create a color cursor.
Definition: SDL_mouse.c:871
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
GLfloat GLfloat GLfloat GLfloat h
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
void * pixels
Definition: SDL_surface.h:75
#define SDL_FreeSurface
uint8_t Uint8
Definition: SDL_stdinc.h:179
GLenum GLint GLuint mask
GLubyte GLubyte GLubyte GLubyte w
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_Cursor * cursor
Definition: testwm2.c:40
#define NULL
Definition: begin_code.h:164
#define SDL_CreateRGBSurface
uint32_t Uint32
Definition: SDL_stdinc.h:203
int uint32_t uint32_t uint32_t uint32_t uint32_t int drmModeModeInfoPtr mode int uint32_t uint32_t uint32_t uint32_t int32_t hot_x
Definition: SDL_kmsdrmsym.h:55

§ SDL_CreateSystemCursor()

SDL_Cursor* SDL_CreateSystemCursor ( SDL_SystemCursor  id)

Create a system cursor.

See also
SDL_FreeCursor()

Definition at line 914 of file SDL_mouse.c.

References SDL_Mouse::CreateSystemCursor, cursor, SDL_Mouse::cursors, SDL_Cursor::next, NULL, SDL_GetMouse(), and SDL_SetError.

915 {
916  SDL_Mouse *mouse = SDL_GetMouse();
918 
919  if (!mouse->CreateSystemCursor) {
920  SDL_SetError("CreateSystemCursor is not currently supported");
921  return NULL;
922  }
923 
924  cursor = mouse->CreateSystemCursor(id);
925  if (cursor) {
926  cursor->next = mouse->cursors;
927  mouse->cursors = cursor;
928  }
929 
930  return cursor;
931 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_Cursor * cursors
Definition: SDL_mouse_c.h:101
SDL_Cursor * cursor
Definition: testwm2.c:40
#define NULL
Definition: begin_code.h:164
struct SDL_Cursor * next
Definition: SDL_mouse_c.h:32
#define SDL_SetError
SDL_Cursor *(* CreateSystemCursor)(SDL_SystemCursor id)
Definition: SDL_mouse_c.h:49

§ SDL_FreeCursor()

void SDL_FreeCursor ( SDL_Cursor cursor)

Frees a cursor created with SDL_CreateCursor() or similar functions.

See also
SDL_CreateCursor()
SDL_CreateColorCursor()
SDL_CreateSystemCursor()

Definition at line 1000 of file SDL_mouse.c.

References SDL_Mouse::cur_cursor, SDL_Mouse::cursors, SDL_Mouse::def_cursor, SDL_Mouse::FreeCursor, SDL_Cursor::next, NULL, SDL_GetMouse(), and SDL_SetCursor().

Referenced by SDL_MouseQuit().

1001 {
1002  SDL_Mouse *mouse = SDL_GetMouse();
1003  SDL_Cursor *curr, *prev;
1004 
1005  if (!cursor) {
1006  return;
1007  }
1008 
1009  if (cursor == mouse->def_cursor) {
1010  return;
1011  }
1012  if (cursor == mouse->cur_cursor) {
1013  SDL_SetCursor(mouse->def_cursor);
1014  }
1015 
1016  for (prev = NULL, curr = mouse->cursors; curr;
1017  prev = curr, curr = curr->next) {
1018  if (curr == cursor) {
1019  if (prev) {
1020  prev->next = curr->next;
1021  } else {
1022  mouse->cursors = curr->next;
1023  }
1024 
1025  if (mouse->FreeCursor) {
1026  mouse->FreeCursor(curr);
1027  }
1028  return;
1029  }
1030  }
1031 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
void SDL_SetCursor(SDL_Cursor *cursor)
Set the active cursor.
Definition: SDL_mouse.c:938
SDL_Cursor * cursors
Definition: SDL_mouse_c.h:101
void(* FreeCursor)(SDL_Cursor *cursor)
Definition: SDL_mouse_c.h:58
#define NULL
Definition: begin_code.h:164
struct SDL_Cursor * next
Definition: SDL_mouse_c.h:32
SDL_Cursor * cur_cursor
Definition: SDL_mouse_c.h:103
SDL_Cursor * def_cursor
Definition: SDL_mouse_c.h:102

§ SDL_GetCursor()

SDL_Cursor* SDL_GetCursor ( void  )

Return the active cursor.

Definition at line 978 of file SDL_mouse.c.

References SDL_Mouse::cur_cursor, NULL, and SDL_GetMouse().

979 {
980  SDL_Mouse *mouse = SDL_GetMouse();
981 
982  if (!mouse) {
983  return NULL;
984  }
985  return mouse->cur_cursor;
986 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define NULL
Definition: begin_code.h:164
SDL_Cursor * cur_cursor
Definition: SDL_mouse_c.h:103

§ SDL_GetDefaultCursor()

SDL_Cursor* SDL_GetDefaultCursor ( void  )

Return the default cursor.

Definition at line 989 of file SDL_mouse.c.

References SDL_Mouse::def_cursor, NULL, and SDL_GetMouse().

990 {
991  SDL_Mouse *mouse = SDL_GetMouse();
992 
993  if (!mouse) {
994  return NULL;
995  }
996  return mouse->def_cursor;
997 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define NULL
Definition: begin_code.h:164
SDL_Cursor * def_cursor
Definition: SDL_mouse_c.h:102

§ SDL_GetGlobalMouseState()

Uint32 SDL_GetGlobalMouseState ( int *  x,
int *  y 
)

Get the current state of the mouse, in relation to the desktop.

This works just like SDL_GetMouseState(), but the coordinates will be reported relative to the top-left of the desktop. This can be useful if you need to track the mouse outside of a specific window and SDL_CaptureMouse() doesn't fit your needs. For example, it could be useful if you need to track the mouse while dragging a window, where coordinates relative to a window might not be in sync at all times.

Note
SDL_GetMouseState() returns the mouse position as SDL understands it from the last pump of the event queue. This function, however, queries the OS for the current mouse position, and as such, might be a slightly less efficient function. Unless you know what you're doing and have a good reason to use this function, you probably want SDL_GetMouseState() instead.
Parameters
xReturns the current X coord, relative to the desktop. Can be NULL.
yReturns the current Y coord, relative to the desktop. Can be NULL.
Returns
The current button state as a bitmask, which can be tested using the SDL_BUTTON(X) macros.
See also
SDL_GetMouseState

Definition at line 659 of file SDL_mouse.c.

References SDL_Mouse::GetGlobalMouseState, and SDL_GetMouse().

660 {
661  SDL_Mouse *mouse = SDL_GetMouse();
662  int tmpx, tmpy;
663 
664  /* make sure these are never NULL for the backend implementations... */
665  if (!x) {
666  x = &tmpx;
667  }
668  if (!y) {
669  y = &tmpy;
670  }
671 
672  *x = *y = 0;
673 
674  if (!mouse->GetGlobalMouseState) {
675  return 0;
676  }
677 
678  return mouse->GetGlobalMouseState(x, y);
679 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Uint32(* GetGlobalMouseState)(int *x, int *y)
Definition: SDL_mouse_c.h:73
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574

§ SDL_GetMouse()

§ SDL_GetMouseFocus()

SDL_Window* SDL_GetMouseFocus ( void  )

Get the window which currently has mouse focus.

Definition at line 150 of file SDL_mouse.c.

References SDL_Mouse::buttonstate, SDL_Mouse::focus, i, SDL_Mouse::mouseID, SDL_assert, SDL_BUTTON, SDL_GetMouse(), SDL_RELEASED, and SDL_SendMouseButton().

151 {
152  SDL_Mouse *mouse = SDL_GetMouse();
153 
154  return mouse->focus;
155 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_Window * focus
Definition: SDL_mouse_c.h:77

§ SDL_GetMouseState()

Uint32 SDL_GetMouseState ( int *  x,
int *  y 
)

Retrieve the current state of the mouse.

The current button state is returned as a button bitmask, which can be tested using the SDL_BUTTON(X) macros, and x and y are set to the mouse cursor position relative to the focus window for the currently selected mouse. You can pass NULL for either x or y.

Definition at line 629 of file SDL_mouse.c.

References SDL_Mouse::buttonstate, SDL_GetMouse(), SDL_Mouse::x, and SDL_Mouse::y.

630 {
631  SDL_Mouse *mouse = SDL_GetMouse();
632 
633  if (x) {
634  *x = mouse->x;
635  }
636  if (y) {
637  *y = mouse->y;
638  }
639  return mouse->buttonstate;
640 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Uint32 buttonstate
Definition: SDL_mouse_c.h:85
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574

§ SDL_GetRelativeMouseMode()

SDL_bool SDL_GetRelativeMouseMode ( void  )

Query whether relative mouse mode is enabled.

See also
SDL_SetRelativeMouseMode()

Definition at line 779 of file SDL_mouse.c.

References SDL_Mouse::relative_mode, and SDL_GetMouse().

780 {
781  SDL_Mouse *mouse = SDL_GetMouse();
782 
783  return mouse->relative_mode;
784 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_bool relative_mode
Definition: SDL_mouse_c.h:87

§ SDL_GetRelativeMouseState()

Uint32 SDL_GetRelativeMouseState ( int *  x,
int *  y 
)

Retrieve the relative state of the mouse.

The current button state is returned as a button bitmask, which can be tested using the SDL_BUTTON(X) macros, and x and y are set to the mouse deltas since the last call to SDL_GetRelativeMouseState().

Definition at line 643 of file SDL_mouse.c.

References SDL_Mouse::buttonstate, SDL_GetMouse(), SDL_Mouse::xdelta, and SDL_Mouse::ydelta.

644 {
645  SDL_Mouse *mouse = SDL_GetMouse();
646 
647  if (x) {
648  *x = mouse->xdelta;
649  }
650  if (y) {
651  *y = mouse->ydelta;
652  }
653  mouse->xdelta = 0;
654  mouse->ydelta = 0;
655  return mouse->buttonstate;
656 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Uint32 buttonstate
Definition: SDL_mouse_c.h:85
int ydelta
Definition: SDL_mouse_c.h:81
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
int xdelta
Definition: SDL_mouse_c.h:80

§ SDL_MouseDoubleClickRadiusChanged()

static void SDL_MouseDoubleClickRadiusChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 57 of file SDL_mouse.c.

References SDL_Mouse::double_click_radius, SDL_atoi, and SDLCALL.

Referenced by SDL_MouseInit().

58 {
59  SDL_Mouse *mouse = (SDL_Mouse *)userdata;
60 
61  if (hint && *hint) {
62  mouse->double_click_radius = SDL_atoi(hint);
63  } else {
64  mouse->double_click_radius = 32; /* 32 pixels seems about right for touch interfaces */
65  }
66 }
int double_click_radius
Definition: SDL_mouse_c.h:94
#define SDL_atoi

§ SDL_MouseDoubleClickTimeChanged()

static void SDL_MouseDoubleClickTimeChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 41 of file SDL_mouse.c.

References SDL_Mouse::double_click_time, SDL_atoi, and SDLCALL.

Referenced by SDL_MouseInit().

42 {
43  SDL_Mouse *mouse = (SDL_Mouse *)userdata;
44 
45  if (hint && *hint) {
46  mouse->double_click_time = SDL_atoi(hint);
47  } else {
48 #ifdef __WIN32__
49  mouse->double_click_time = GetDoubleClickTime();
50 #else
51  mouse->double_click_time = 500;
52 #endif
53  }
54 }
Uint32 double_click_time
Definition: SDL_mouse_c.h:93
#define SDL_atoi

§ SDL_MouseInit()

int SDL_MouseInit ( void  )

Definition at line 106 of file SDL_mouse.c.

References SDL_Mouse::cursor_shown, SDL_AddHintCallback, SDL_GetMouse(), SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS, SDL_HINT_MOUSE_DOUBLE_CLICK_TIME, SDL_HINT_MOUSE_NORMAL_SPEED_SCALE, SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE, SDL_HINT_TOUCH_MOUSE_EVENTS, SDL_MouseDoubleClickRadiusChanged(), SDL_MouseDoubleClickTimeChanged(), SDL_MouseNormalSpeedScaleChanged(), SDL_MouseRelativeSpeedScaleChanged(), SDL_TouchMouseEventsChanged(), SDL_TRUE, and SDL_zerop.

Referenced by SDL_VideoInit().

107 {
108  SDL_Mouse *mouse = SDL_GetMouse();
109 
110  SDL_zerop(mouse);
111 
114 
117 
120 
123 
126 
127  mouse->cursor_shown = SDL_TRUE;
128 
129  return (0);
130 }
#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE
A variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode...
Definition: SDL_hints.h:283
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define SDL_HINT_TOUCH_MOUSE_EVENTS
A variable controlling whether touch events should generate synthetic mouse events.
Definition: SDL_hints.h:316
static void SDL_MouseDoubleClickTimeChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:41
#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS
A variable setting the double click radius, in pixels.
Definition: SDL_hints.h:273
static void SDL_TouchMouseEventsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:93
static void SDL_MouseNormalSpeedScaleChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:69
#define SDL_zerop(x)
Definition: SDL_stdinc.h:417
SDL_bool cursor_shown
Definition: SDL_mouse_c.h:104
static void SDL_MouseDoubleClickRadiusChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:57
static void SDL_MouseRelativeSpeedScaleChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:81
#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME
A variable setting the double click time, in milliseconds.
Definition: SDL_hints.h:268
#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE
A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in rela...
Definition: SDL_hints.h:278
#define SDL_AddHintCallback

§ SDL_MouseNormalSpeedScaleChanged()

static void SDL_MouseNormalSpeedScaleChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 69 of file SDL_mouse.c.

References SDL_Mouse::normal_speed_scale, SDL_atof, and SDLCALL.

Referenced by SDL_MouseInit(), and SDL_MouseQuit().

70 {
71  SDL_Mouse *mouse = (SDL_Mouse *)userdata;
72 
73  if (hint && *hint) {
74  mouse->normal_speed_scale = (float)SDL_atof(hint);
75  } else {
76  mouse->normal_speed_scale = 1.0f;
77  }
78 }
#define SDL_atof
float normal_speed_scale
Definition: SDL_mouse_c.h:89

§ SDL_MouseQuit()

void SDL_MouseQuit ( void  )

Definition at line 592 of file SDL_mouse.c.

References SDL_Mouse::CaptureMouse, SDL_Mouse::clickstate, cursor, SDL_Mouse::cursors, SDL_Mouse::def_cursor, SDL_Mouse::FreeCursor, SDL_Cursor::next, NULL, SDL_CaptureMouse(), SDL_DelHintCallback, SDL_FALSE, SDL_free, SDL_FreeCursor(), SDL_GetMouse(), SDL_HINT_MOUSE_NORMAL_SPEED_SCALE, SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE, SDL_MouseNormalSpeedScaleChanged(), SDL_MouseRelativeSpeedScaleChanged(), SDL_SetRelativeMouseMode(), and SDL_ShowCursor().

Referenced by SDL_VideoQuit().

593 {
594  SDL_Cursor *cursor, *next;
595  SDL_Mouse *mouse = SDL_GetMouse();
596 
597  if (mouse->CaptureMouse) {
599  }
601  SDL_ShowCursor(1);
602 
603  cursor = mouse->cursors;
604  while (cursor) {
605  next = cursor->next;
606  SDL_FreeCursor(cursor);
607  cursor = next;
608  }
609  mouse->cursors = NULL;
610 
611  if (mouse->def_cursor && mouse->FreeCursor) {
612  mouse->FreeCursor(mouse->def_cursor);
613  mouse->def_cursor = NULL;
614  }
615 
616  if (mouse->clickstate) {
617  SDL_free(mouse->clickstate);
618  mouse->clickstate = NULL;
619  }
620 
623 
626 }
#define SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE
A variable setting the scale for mouse motion, in floating point, when the mouse is in relative mode...
Definition: SDL_hints.h:283
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_MouseClickState * clickstate
Definition: SDL_mouse_c.h:99
static void SDL_MouseNormalSpeedScaleChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:69
int SDL_ShowCursor(int toggle)
Toggle whether or not the cursor is shown.
Definition: SDL_mouse.c:1034
SDL_Cursor * cursors
Definition: SDL_mouse_c.h:101
int SDL_CaptureMouse(SDL_bool enabled)
Capture the mouse, to track input outside an SDL window.
Definition: SDL_mouse.c:787
int(* CaptureMouse)(SDL_Window *window)
Definition: SDL_mouse_c.h:70
#define SDL_free
SDL_Cursor * cursor
Definition: testwm2.c:40
static void SDL_MouseRelativeSpeedScaleChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
Definition: SDL_mouse.c:81
void(* FreeCursor)(SDL_Cursor *cursor)
Definition: SDL_mouse_c.h:58
#define NULL
Definition: begin_code.h:164
struct SDL_Cursor * next
Definition: SDL_mouse_c.h:32
#define SDL_HINT_MOUSE_NORMAL_SPEED_SCALE
A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in rela...
Definition: SDL_hints.h:278
int SDL_SetRelativeMouseMode(SDL_bool enabled)
Set relative mouse mode.
Definition: SDL_mouse.c:725
#define SDL_DelHintCallback
void SDL_FreeCursor(SDL_Cursor *cursor)
Frees a cursor created with SDL_CreateCursor() or similar functions.
Definition: SDL_mouse.c:1000
SDL_Cursor * def_cursor
Definition: SDL_mouse_c.h:102

§ SDL_MouseRelativeSpeedScaleChanged()

static void SDL_MouseRelativeSpeedScaleChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 81 of file SDL_mouse.c.

References SDL_Mouse::relative_speed_scale, SDL_atof, and SDLCALL.

Referenced by SDL_MouseInit(), and SDL_MouseQuit().

82 {
83  SDL_Mouse *mouse = (SDL_Mouse *)userdata;
84 
85  if (hint && *hint) {
86  mouse->relative_speed_scale = (float)SDL_atof(hint);
87  } else {
88  mouse->relative_speed_scale = 1.0f;
89  }
90 }
#define SDL_atof
float relative_speed_scale
Definition: SDL_mouse_c.h:90

§ SDL_PrivateSendMouseButton()

static int SDL_PrivateSendMouseButton ( SDL_Window window,
SDL_MouseID  mouseID,
Uint8  state,
Uint8  button,
int  clicks 
)
static

Definition at line 440 of file SDL_mouse.c.

References button, SDL_Mouse::buttonstate, SDL_MouseClickState::click_count, SDL_Mouse::double_click_radius, SDL_Mouse::double_click_time, SDL_Mouse::focus, GetMouseClickState(), SDL_Window::id, SDL_MouseClickState::last_timestamp, SDL_MouseClickState::last_x, SDL_MouseClickState::last_y, SDL_abs, SDL_BUTTON, SDL_ENABLE, SDL_GetEventState, SDL_GetMouse(), SDL_GetTicks(), SDL_min, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_PRESSED, SDL_PushEvent, SDL_RELEASED, SDL_TICKS_PASSED, SDL_TOUCH_MOUSEID, SDL_UpdateMouseFocus(), state, SDL_Mouse::touch_mouse_events, SDL_Mouse::x, and SDL_Mouse::y.

Referenced by SDL_SendMouseButton(), and SDL_SendMouseButtonClicks().

441 {
442  SDL_Mouse *mouse = SDL_GetMouse();
443  int posted;
444  Uint32 type;
445  Uint32 buttonstate = mouse->buttonstate;
446 
447  if (mouseID == SDL_TOUCH_MOUSEID && !mouse->touch_mouse_events) {
448  return 0;
449  }
450 
451  /* Figure out which event to perform */
452  switch (state) {
453  case SDL_PRESSED:
454  type = SDL_MOUSEBUTTONDOWN;
455  buttonstate |= SDL_BUTTON(button);
456  break;
457  case SDL_RELEASED:
458  type = SDL_MOUSEBUTTONUP;
459  buttonstate &= ~SDL_BUTTON(button);
460  break;
461  default:
462  /* Invalid state -- bail */
463  return 0;
464  }
465 
466  /* We do this after calculating buttonstate so button presses gain focus */
467  if (window && state == SDL_PRESSED) {
468  SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
469  }
470 
471  if (buttonstate == mouse->buttonstate) {
472  /* Ignore this event, no state change */
473  return 0;
474  }
475  mouse->buttonstate = buttonstate;
476 
477  if (clicks < 0) {
478  SDL_MouseClickState *clickstate = GetMouseClickState(mouse, button);
479  if (clickstate) {
480  if (state == SDL_PRESSED) {
481  Uint32 now = SDL_GetTicks();
482 
483  if (SDL_TICKS_PASSED(now, clickstate->last_timestamp + mouse->double_click_time) ||
484  SDL_abs(mouse->x - clickstate->last_x) > mouse->double_click_radius ||
485  SDL_abs(mouse->y - clickstate->last_y) > mouse->double_click_radius) {
486  clickstate->click_count = 0;
487  }
488  clickstate->last_timestamp = now;
489  clickstate->last_x = mouse->x;
490  clickstate->last_y = mouse->y;
491  if (clickstate->click_count < 255) {
492  ++clickstate->click_count;
493  }
494  }
495  clicks = clickstate->click_count;
496  } else {
497  clicks = 1;
498  }
499  }
500 
501  /* Post the event, if desired */
502  posted = 0;
503  if (SDL_GetEventState(type) == SDL_ENABLE) {
505  event.type = type;
506  event.button.windowID = mouse->focus ? mouse->focus->id : 0;
507  event.button.which = mouseID;
508  event.button.state = state;
509  event.button.button = button;
510  event.button.clicks = (Uint8) SDL_min(clicks, 255);
511  event.button.x = mouse->x;
512  event.button.y = mouse->y;
513  posted = (SDL_PushEvent(&event) > 0);
514  }
515 
516  /* We do this after dispatching event so button releases can lose focus */
517  if (window && state == SDL_RELEASED) {
518  SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate);
519  }
520 
521  return posted;
522 }
int double_click_radius
Definition: SDL_mouse_c.h:94
#define SDL_abs
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define SDL_min(x, y)
Definition: SDL_stdinc.h:406
SDL_Texture * button
Uint32 buttonstate
Definition: SDL_mouse_c.h:85
SDL_Window * focus
Definition: SDL_mouse_c.h:77
struct xkb_state * state
#define SDL_ENABLE
Definition: SDL_events.h:756
#define SDL_TOUCH_MOUSEID
Definition: SDL_touch.h:53
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
SDL_bool touch_mouse_events
Definition: SDL_mouse_c.h:95
uint8_t Uint8
Definition: SDL_stdinc.h:179
struct _cl_event * event
#define SDL_PushEvent
Uint32 double_click_time
Definition: SDL_mouse_c.h:93
static SDL_MouseClickState * GetMouseClickState(SDL_Mouse *mouse, Uint8 button)
Definition: SDL_mouse.c:421
static SDL_bool SDL_UpdateMouseFocus(SDL_Window *window, int x, int y, Uint32 buttonstate)
Definition: SDL_mouse.c:215
uint32_t Uint32
Definition: SDL_stdinc.h:203
Uint32 id
Definition: SDL_sysvideo.h:76
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571
#define SDL_BUTTON(X)
Definition: SDL_mouse.h:281
General event structure.
Definition: SDL_events.h:557
#define SDL_PRESSED
Definition: SDL_events.h:50
#define SDL_TICKS_PASSED(A, B)
Compare SDL ticks values, and return true if A has passed B.
Definition: SDL_timer.h:56
#define SDL_RELEASED
Definition: SDL_events.h:49

§ SDL_PrivateSendMouseMotion()

static int SDL_PrivateSendMouseMotion ( SDL_Window window,
SDL_MouseID  mouseID,
int  relative,
int  x,
int  y 
)
static

Definition at line 291 of file SDL_mouse.c.

References SDL_Mouse::buttonstate, SDL_Mouse::cur_cursor, SDL_Mouse::cursor_shown, SDL_Window::flags, SDL_Mouse::focus, GetScaledMouseDelta(), SDL_Mouse::has_position, SDL_Window::id, SDL_Mouse::last_x, SDL_Mouse::last_y, SDL_Mouse::MoveCursor, SDL_Mouse::normal_speed_scale, SDL_Mouse::relative_mode, SDL_Mouse::relative_mode_warp, SDL_Mouse::relative_speed_scale, SDL_Mouse::scale_accum_x, SDL_Mouse::scale_accum_y, SDL_ENABLE, SDL_GetEventState, SDL_GetMouse(), SDL_GetWindowSize, SDL_MOUSEMOTION, SDL_PushEvent, SDL_TOUCH_MOUSEID, SDL_TRUE, SDL_WarpMouseInWindow(), SDL_WINDOW_MOUSE_CAPTURE, SDL_Mouse::touch_mouse_events, SDL_Mouse::x, SDL_Mouse::xdelta, SDL_Mouse::y, and SDL_Mouse::ydelta.

Referenced by SDL_SendMouseMotion(), and SDL_UpdateMouseFocus().

292 {
293  SDL_Mouse *mouse = SDL_GetMouse();
294  int posted;
295  int xrel;
296  int yrel;
297 
298  if (mouseID == SDL_TOUCH_MOUSEID && !mouse->touch_mouse_events) {
299  return 0;
300  }
301 
302  if (mouseID != SDL_TOUCH_MOUSEID && mouse->relative_mode_warp) {
303  int center_x = 0, center_y = 0;
304  SDL_GetWindowSize(window, &center_x, &center_y);
305  center_x /= 2;
306  center_y /= 2;
307  if (x == center_x && y == center_y) {
308  mouse->last_x = center_x;
309  mouse->last_y = center_y;
310  return 0;
311  }
312  SDL_WarpMouseInWindow(window, center_x, center_y);
313  }
314 
315  if (relative) {
316  if (mouse->relative_mode) {
319  } else {
322  }
323  xrel = x;
324  yrel = y;
325  x = (mouse->last_x + xrel);
326  y = (mouse->last_y + yrel);
327  } else {
328  xrel = x - mouse->last_x;
329  yrel = y - mouse->last_y;
330  }
331 
332  /* Drop events that don't change state */
333  if (!xrel && !yrel) {
334 #ifdef DEBUG_MOUSE
335  printf("Mouse event didn't change state - dropped!\n");
336 #endif
337  return 0;
338  }
339 
340  /* Ignore relative motion when first positioning the mouse */
341  if (!mouse->has_position) {
342  xrel = 0;
343  yrel = 0;
344  mouse->has_position = SDL_TRUE;
345  }
346 
347  /* Ignore relative motion positioning the first touch */
348  if (mouseID == SDL_TOUCH_MOUSEID && !mouse->buttonstate) {
349  xrel = 0;
350  yrel = 0;
351  }
352 
353  /* Update internal mouse coordinates */
354  if (!mouse->relative_mode) {
355  mouse->x = x;
356  mouse->y = y;
357  } else {
358  mouse->x += xrel;
359  mouse->y += yrel;
360  }
361 
362  /* make sure that the pointers find themselves inside the windows,
363  unless we have the mouse captured. */
364  if (window && ((window->flags & SDL_WINDOW_MOUSE_CAPTURE) == 0)) {
365  int x_max = 0, y_max = 0;
366 
367  /* !!! FIXME: shouldn't this be (window) instead of (mouse->focus)? */
368  SDL_GetWindowSize(mouse->focus, &x_max, &y_max);
369  --x_max;
370  --y_max;
371 
372  if (mouse->x > x_max) {
373  mouse->x = x_max;
374  }
375  if (mouse->x < 0) {
376  mouse->x = 0;
377  }
378 
379  if (mouse->y > y_max) {
380  mouse->y = y_max;
381  }
382  if (mouse->y < 0) {
383  mouse->y = 0;
384  }
385  }
386 
387  mouse->xdelta += xrel;
388  mouse->ydelta += yrel;
389 
390  /* Move the mouse cursor, if needed */
391  if (mouse->cursor_shown && !mouse->relative_mode &&
392  mouse->MoveCursor && mouse->cur_cursor) {
393  mouse->MoveCursor(mouse->cur_cursor);
394  }
395 
396  /* Post the event, if desired */
397  posted = 0;
400  event.motion.type = SDL_MOUSEMOTION;
401  event.motion.windowID = mouse->focus ? mouse->focus->id : 0;
402  event.motion.which = mouseID;
403  event.motion.state = mouse->buttonstate;
404  event.motion.x = mouse->x;
405  event.motion.y = mouse->y;
406  event.motion.xrel = xrel;
407  event.motion.yrel = yrel;
408  posted = (SDL_PushEvent(&event) > 0);
409  }
410  if (relative) {
411  mouse->last_x = mouse->x;
412  mouse->last_y = mouse->y;
413  } else {
414  /* Use unclamped values if we're getting events outside the window */
415  mouse->last_x = x;
416  mouse->last_y = y;
417  }
418  return posted;
419 }
int last_y
Definition: SDL_mouse_c.h:82
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_bool has_position
Definition: SDL_mouse_c.h:86
int last_x
Definition: SDL_mouse_c.h:82
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Uint32 buttonstate
Definition: SDL_mouse_c.h:85
SDL_bool relative_mode_warp
Definition: SDL_mouse_c.h:88
SDL_Window * focus
Definition: SDL_mouse_c.h:77
float scale_accum_y
Definition: SDL_mouse_c.h:92
#define SDL_ENABLE
Definition: SDL_events.h:756
int ydelta
Definition: SDL_mouse_c.h:81
#define SDL_TOUCH_MOUSEID
Definition: SDL_touch.h:53
void SDL_WarpMouseInWindow(SDL_Window *window, int x, int y)
Moves the mouse to the given position within the window.
Definition: SDL_mouse.c:682
#define SDL_GetWindowSize
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
static int GetScaledMouseDelta(float scale, int value, float *accum)
Definition: SDL_mouse.c:276
SDL_bool touch_mouse_events
Definition: SDL_mouse_c.h:95
struct _cl_event * event
SDL_bool cursor_shown
Definition: SDL_mouse_c.h:104
SDL_bool relative_mode
Definition: SDL_mouse_c.h:87
#define SDL_PushEvent
float scale_accum_x
Definition: SDL_mouse_c.h:91
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
float normal_speed_scale
Definition: SDL_mouse_c.h:89
int xdelta
Definition: SDL_mouse_c.h:80
Uint32 id
Definition: SDL_sysvideo.h:76
General event structure.
Definition: SDL_events.h:557
SDL_Cursor * cur_cursor
Definition: SDL_mouse_c.h:103
Uint32 flags
Definition: SDL_sysvideo.h:83
void(* MoveCursor)(SDL_Cursor *cursor)
Definition: SDL_mouse_c.h:55
float relative_speed_scale
Definition: SDL_mouse_c.h:90

§ SDL_SendMouseButton()

int SDL_SendMouseButton ( SDL_Window window,
SDL_MouseID  mouseID,
Uint8  state,
Uint8  button 
)

Definition at line 532 of file SDL_mouse.c.

References SDL_PrivateSendMouseButton().

Referenced by SDL_BApp::_HandleMouseButton(), and SDL_GetMouseFocus().

533 {
534  return SDL_PrivateSendMouseButton(window, mouseID, state, button, -1);
535 }
static int SDL_PrivateSendMouseButton(SDL_Window *window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks)
Definition: SDL_mouse.c:440
SDL_Texture * button
struct xkb_state * state

§ SDL_SendMouseButtonClicks()

int SDL_SendMouseButtonClicks ( SDL_Window window,
SDL_MouseID  mouseID,
Uint8  state,
Uint8  button,
int  clicks 
)

Definition at line 525 of file SDL_mouse.c.

References SDL_max, and SDL_PrivateSendMouseButton().

526 {
527  clicks = SDL_max(clicks, 0);
528  return SDL_PrivateSendMouseButton(window, mouseID, state, button, clicks);
529 }
static int SDL_PrivateSendMouseButton(SDL_Window *window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks)
Definition: SDL_mouse.c:440
SDL_Texture * button
struct xkb_state * state
#define SDL_max(x, y)
Definition: SDL_stdinc.h:407

§ SDL_SendMouseMotion()

int SDL_SendMouseMotion ( SDL_Window window,
SDL_MouseID  mouseID,
int  relative,
int  x,
int  y 
)

Definition at line 263 of file SDL_mouse.c.

References SDL_Mouse::buttonstate, SDL_GetMouse(), SDL_PrivateSendMouseMotion(), and SDL_UpdateMouseFocus().

Referenced by SDL_BApp::_HandleMouseMove(), IsSDLWindowEventPending(), and SDL_WarpMouseInWindow().

264 {
265  if (window && !relative) {
266  SDL_Mouse *mouse = SDL_GetMouse();
267  if (!SDL_UpdateMouseFocus(window, x, y, mouse->buttonstate)) {
268  return 0;
269  }
270  }
271 
272  return SDL_PrivateSendMouseMotion(window, mouseID, relative, x, y);
273 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
static int SDL_PrivateSendMouseMotion(SDL_Window *window, SDL_MouseID mouseID, int relative, int x, int y)
Definition: SDL_mouse.c:291
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
Uint32 buttonstate
Definition: SDL_mouse_c.h:85
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
static SDL_bool SDL_UpdateMouseFocus(SDL_Window *window, int x, int y, Uint32 buttonstate)
Definition: SDL_mouse.c:215

§ SDL_SendMouseWheel()

int SDL_SendMouseWheel ( SDL_Window window,
SDL_MouseID  mouseID,
float  x,
float  y,
SDL_MouseWheelDirection  direction 
)

Definition at line 538 of file SDL_mouse.c.

References SDL_Mouse::accumulated_wheel_x, SDL_Mouse::accumulated_wheel_y, SDL_Mouse::focus, SDL_Window::id, SDL_ceil, SDL_ENABLE, SDL_floor, SDL_GetEventState, SDL_GetMouse(), SDL_MOUSEWHEEL, SDL_PushEvent, and SDL_SetMouseFocus().

Referenced by SDL_BApp::_HandleMouseWheel().

539 {
540  SDL_Mouse *mouse = SDL_GetMouse();
541  int posted;
542  int integral_x, integral_y;
543 
544  if (window) {
545  SDL_SetMouseFocus(window);
546  }
547 
548  if (!x && !y) {
549  return 0;
550  }
551 
552  mouse->accumulated_wheel_x += x;
553  if (mouse->accumulated_wheel_x > 0) {
554  integral_x = (int)SDL_floor(mouse->accumulated_wheel_x);
555  } else if (mouse->accumulated_wheel_x < 0) {
556  integral_x = (int)SDL_ceil(mouse->accumulated_wheel_x);
557  } else {
558  integral_x = 0;
559  }
560  mouse->accumulated_wheel_x -= integral_x;
561 
562  mouse->accumulated_wheel_y += y;
563  if (mouse->accumulated_wheel_y > 0) {
564  integral_y = (int)SDL_floor(mouse->accumulated_wheel_y);
565  } else if (mouse->accumulated_wheel_y < 0) {
566  integral_y = (int)SDL_ceil(mouse->accumulated_wheel_y);
567  } else {
568  integral_y = 0;
569  }
570  mouse->accumulated_wheel_y -= integral_y;
571 
572  /* Post the event, if desired */
573  posted = 0;
576  event.type = SDL_MOUSEWHEEL;
577  event.wheel.windowID = mouse->focus ? mouse->focus->id : 0;
578  event.wheel.which = mouseID;
579 #if 0 /* Uncomment this when it goes in for SDL 2.1 */
580  event.wheel.preciseX = x;
581  event.wheel.preciseY = y;
582 #endif
583  event.wheel.x = integral_x;
584  event.wheel.y = integral_y;
585  event.wheel.direction = (Uint32)direction;
586  posted = (SDL_PushEvent(&event) > 0);
587  }
588  return posted;
589 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
#define SDL_ceil
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
SDL_Window * focus
Definition: SDL_mouse_c.h:77
#define SDL_ENABLE
Definition: SDL_events.h:756
void SDL_SetMouseFocus(SDL_Window *window)
Definition: SDL_mouse.c:177
#define SDL_floor
#define SDL_GetEventState(type)
Definition: SDL_events.h:769
struct _cl_event * event
float accumulated_wheel_y
Definition: SDL_mouse_c.h:84
#define SDL_PushEvent
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
uint32_t Uint32
Definition: SDL_stdinc.h:203
Uint32 id
Definition: SDL_sysvideo.h:76
General event structure.
Definition: SDL_events.h:557
float accumulated_wheel_x
Definition: SDL_mouse_c.h:83

§ SDL_SetCursor()

void SDL_SetCursor ( SDL_Cursor cursor)

Set the active cursor.

Definition at line 938 of file SDL_mouse.c.

References SDL_Mouse::cur_cursor, cursor, SDL_Mouse::cursor_shown, SDL_Mouse::cursors, SDL_Mouse::def_cursor, SDL_Mouse::focus, SDL_Cursor::next, NULL, SDL_Mouse::relative_mode, SDL_GetMouse(), SDL_SetError, and SDL_Mouse::ShowCursor.

Referenced by SDL_FreeCursor(), SDL_SetDefaultCursor(), SDL_SetMouseFocus(), SDL_SetRelativeMouseMode(), and SDL_ShowCursor().

939 {
940  SDL_Mouse *mouse = SDL_GetMouse();
941 
942  /* Set the new cursor */
943  if (cursor) {
944  /* Make sure the cursor is still valid for this mouse */
945  if (cursor != mouse->def_cursor) {
946  SDL_Cursor *found;
947  for (found = mouse->cursors; found; found = found->next) {
948  if (found == cursor) {
949  break;
950  }
951  }
952  if (!found) {
953  SDL_SetError("Cursor not associated with the current mouse");
954  return;
955  }
956  }
957  mouse->cur_cursor = cursor;
958  } else {
959  if (mouse->focus) {
960  cursor = mouse->cur_cursor;
961  } else {
962  cursor = mouse->def_cursor;
963  }
964  }
965 
966  if (cursor && mouse->cursor_shown && !mouse->relative_mode) {
967  if (mouse->ShowCursor) {
968  mouse->ShowCursor(cursor);
969  }
970  } else {
971  if (mouse->ShowCursor) {
972  mouse->ShowCursor(NULL);
973  }
974  }
975 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
int(* ShowCursor)(SDL_Cursor *cursor)
Definition: SDL_mouse_c.h:52
SDL_Window * focus
Definition: SDL_mouse_c.h:77
SDL_Cursor * cursors
Definition: SDL_mouse_c.h:101
SDL_bool cursor_shown
Definition: SDL_mouse_c.h:104
SDL_bool relative_mode
Definition: SDL_mouse_c.h:87
SDL_Cursor * cursor
Definition: testwm2.c:40
#define NULL
Definition: begin_code.h:164
struct SDL_Cursor * next
Definition: SDL_mouse_c.h:32
#define SDL_SetError
SDL_Cursor * cur_cursor
Definition: SDL_mouse_c.h:103
SDL_Cursor * def_cursor
Definition: SDL_mouse_c.h:102

§ SDL_SetDefaultCursor()

void SDL_SetDefaultCursor ( SDL_Cursor cursor)

Definition at line 133 of file SDL_mouse.c.

References SDL_Mouse::cur_cursor, cursor, SDL_Mouse::def_cursor, SDL_GetMouse(), and SDL_SetCursor().

134 {
135  SDL_Mouse *mouse = SDL_GetMouse();
136 
137  mouse->def_cursor = cursor;
138  if (!mouse->cur_cursor) {
139  SDL_SetCursor(cursor);
140  }
141 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
void SDL_SetCursor(SDL_Cursor *cursor)
Set the active cursor.
Definition: SDL_mouse.c:938
SDL_Cursor * cursor
Definition: testwm2.c:40
SDL_Cursor * cur_cursor
Definition: SDL_mouse_c.h:103
SDL_Cursor * def_cursor
Definition: SDL_mouse_c.h:102

§ SDL_SetMouseFocus()

void SDL_SetMouseFocus ( SDL_Window window)

Definition at line 177 of file SDL_mouse.c.

References SDL_Mouse::focus, SDL_Mouse::has_position, NULL, SDL_FALSE, SDL_GetMouse(), SDL_SendWindowEvent(), SDL_SetCursor(), SDL_WINDOWEVENT_ENTER, and SDL_WINDOWEVENT_LEAVE.

Referenced by SDL_BApp::_HandleMouseFocus(), SDL_DestroyWindow(), SDL_OnWindowFocusGained(), SDL_SendMouseWheel(), SDL_SetRelativeMouseMode(), and SDL_UpdateMouseFocus().

178 {
179  SDL_Mouse *mouse = SDL_GetMouse();
180 
181  if (mouse->focus == window) {
182  return;
183  }
184 
185  /* Actually, this ends up being a bad idea, because most operating
186  systems have an implicit grab when you press the mouse button down
187  so you can drag things out of the window and then get the mouse up
188  when it happens. So, #if 0...
189  */
190 #if 0
191  if (mouse->focus && !window) {
192  /* We won't get anymore mouse messages, so reset mouse state */
193  SDL_ResetMouse();
194  }
195 #endif
196 
197  /* See if the current window has lost focus */
198  if (mouse->focus) {
200  }
201 
202  mouse->focus = window;
203  mouse->has_position = SDL_FALSE;
204 
205  if (mouse->focus) {
207  }
208 
209  /* Update cursor visibility */
211 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_bool has_position
Definition: SDL_mouse_c.h:86
SDL_Window * focus
Definition: SDL_mouse_c.h:77
void SDL_SetCursor(SDL_Cursor *cursor)
Set the active cursor.
Definition: SDL_mouse.c:938
int SDL_SendWindowEvent(SDL_Window *window, Uint8 windowevent, int data1, int data2)
#define NULL
Definition: begin_code.h:164
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025

§ SDL_SetRelativeMouseMode()

int SDL_SetRelativeMouseMode ( SDL_bool  enabled)

Set relative mouse mode.

Parameters
enabledWhether or not to enable relative mode
Returns
0 on success, or -1 if relative mode is not supported.

While the mouse is in relative mode, the cursor is hidden, and the driver will try to report continuous motion in the current window. Only relative motion events will be delivered, the mouse position will not change.

Note
This function will flush any pending mouse motion.
See also
SDL_GetRelativeMouseMode()

Definition at line 725 of file SDL_mouse.c.

References SDL_Mouse::focus, SDL_Window::h, NULL, SDL_Mouse::relative_mode, SDL_Mouse::relative_mode_warp, SDL_Mouse::scale_accum_x, SDL_Mouse::scale_accum_y, SDL_FALSE, SDL_FlushEvent, SDL_GetKeyboardFocus, SDL_GetMouse(), SDL_MOUSEMOTION, SDL_SetCursor(), SDL_SetError, SDL_SetMouseFocus(), SDL_TRUE, SDL_UpdateWindowGrab(), SDL_WarpMouseInWindow(), SDL_Mouse::SetRelativeMouseMode, ShouldUseRelativeModeWarp(), SDL_Window::w, SDL_Mouse::WarpMouse, SDL_Mouse::x, and SDL_Mouse::y.

Referenced by SDL_MouseQuit().

726 {
727  SDL_Mouse *mouse = SDL_GetMouse();
728  SDL_Window *focusWindow = SDL_GetKeyboardFocus();
729 
730  if (enabled == mouse->relative_mode) {
731  return 0;
732  }
733 
734  if (enabled && focusWindow) {
735  /* Center it in the focused window to prevent clicks from going through
736  * to background windows.
737  */
738  SDL_SetMouseFocus(focusWindow);
739  SDL_WarpMouseInWindow(focusWindow, focusWindow->w/2, focusWindow->h/2);
740  }
741 
742  /* Set the relative mode */
743  if (!enabled && mouse->relative_mode_warp) {
744  mouse->relative_mode_warp = SDL_FALSE;
745  } else if (enabled && ShouldUseRelativeModeWarp(mouse)) {
746  mouse->relative_mode_warp = SDL_TRUE;
747  } else if (mouse->SetRelativeMouseMode(enabled) < 0) {
748  if (enabled) {
749  /* Fall back to warp mode if native relative mode failed */
750  if (!mouse->WarpMouse) {
751  return SDL_SetError("No relative mode implementation available");
752  }
753  mouse->relative_mode_warp = SDL_TRUE;
754  }
755  }
756  mouse->relative_mode = enabled;
757  mouse->scale_accum_x = 0.0f;
758  mouse->scale_accum_y = 0.0f;
759 
760  if (mouse->focus) {
761  SDL_UpdateWindowGrab(mouse->focus);
762 
763  /* Put the cursor back to where the application expects it */
764  if (!enabled) {
765  SDL_WarpMouseInWindow(mouse->focus, mouse->x, mouse->y);
766  }
767  }
768 
769  /* Flush pending mouse motion - ideally we would pump events, but that's not always safe */
771 
772  /* Update cursor visibility */
774 
775  return 0;
776 }
void SDL_UpdateWindowGrab(SDL_Window *window)
Definition: SDL_video.c:2504
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
SDL_bool relative_mode_warp
Definition: SDL_mouse_c.h:88
SDL_Window * focus
Definition: SDL_mouse_c.h:77
#define SDL_FlushEvent
int(* SetRelativeMouseMode)(SDL_bool enabled)
Definition: SDL_mouse_c.h:67
float scale_accum_y
Definition: SDL_mouse_c.h:92
void SDL_SetCursor(SDL_Cursor *cursor)
Set the active cursor.
Definition: SDL_mouse.c:938
void SDL_SetMouseFocus(SDL_Window *window)
Definition: SDL_mouse.c:177
#define SDL_GetKeyboardFocus
void SDL_WarpMouseInWindow(SDL_Window *window, int x, int y)
Moves the mouse to the given position within the window.
Definition: SDL_mouse.c:682
SDL_bool relative_mode
Definition: SDL_mouse_c.h:87
float scale_accum_x
Definition: SDL_mouse_c.h:91
GLenum GLenum GLsizei const GLuint GLboolean enabled
#define NULL
Definition: begin_code.h:164
#define SDL_SetError
The type used to identify a window.
Definition: SDL_sysvideo.h:73
void(* WarpMouse)(SDL_Window *window, int x, int y)
Definition: SDL_mouse_c.h:61
static SDL_bool ShouldUseRelativeModeWarp(SDL_Mouse *mouse)
Definition: SDL_mouse.c:714

§ SDL_ShowCursor()

int SDL_ShowCursor ( int  toggle)

Toggle whether or not the cursor is shown.

Parameters
toggle1 to show the cursor, 0 to hide it, -1 to query the current state.
Returns
1 if the cursor is shown, or 0 if the cursor is hidden.

Definition at line 1034 of file SDL_mouse.c.

References SDL_Mouse::cursor_shown, NULL, SDL_FALSE, SDL_GetMouse(), SDL_SetCursor(), and SDL_TRUE.

Referenced by SDL_MouseQuit().

1035 {
1036  SDL_Mouse *mouse = SDL_GetMouse();
1037  SDL_bool shown;
1038 
1039  if (!mouse) {
1040  return 0;
1041  }
1042 
1043  shown = mouse->cursor_shown;
1044  if (toggle >= 0) {
1045  if (toggle) {
1046  mouse->cursor_shown = SDL_TRUE;
1047  } else {
1048  mouse->cursor_shown = SDL_FALSE;
1049  }
1050  if (mouse->cursor_shown != shown) {
1052  }
1053  }
1054  return shown;
1055 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
void SDL_SetCursor(SDL_Cursor *cursor)
Set the active cursor.
Definition: SDL_mouse.c:938
SDL_bool cursor_shown
Definition: SDL_mouse_c.h:104
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:161

§ SDL_TouchMouseEventsChanged()

static void SDL_TouchMouseEventsChanged ( void userdata,
const char *  name,
const char *  oldValue,
const char *  hint 
)
static

Definition at line 93 of file SDL_mouse.c.

References SDL_FALSE, SDL_strcasecmp, SDL_TRUE, and SDL_Mouse::touch_mouse_events.

Referenced by SDL_MouseInit().

94 {
95  SDL_Mouse *mouse = (SDL_Mouse *)userdata;
96 
97  if (hint && (*hint == '0' || SDL_strcasecmp(hint, "false") == 0)) {
99  } else {
100  mouse->touch_mouse_events = SDL_TRUE;
101  }
102 }
#define SDL_strcasecmp
SDL_bool touch_mouse_events
Definition: SDL_mouse_c.h:95

§ SDL_UpdateMouseFocus()

static SDL_bool SDL_UpdateMouseFocus ( SDL_Window window,
int  x,
int  y,
Uint32  buttonstate 
)
static

Definition at line 215 of file SDL_mouse.c.

References SDL_Window::flags, SDL_Mouse::focus, SDL_Mouse::mouseID, NULL, SDL_FALSE, SDL_GetMouse(), SDL_GetWindowSize, SDL_PrivateSendMouseMotion(), SDL_SetMouseFocus(), SDL_TRUE, and SDL_WINDOW_MOUSE_CAPTURE.

Referenced by SDL_PrivateSendMouseButton(), and SDL_SendMouseMotion().

216 {
217  SDL_Mouse *mouse = SDL_GetMouse();
218  SDL_bool inWindow = SDL_TRUE;
219 
220  if (window && ((window->flags & SDL_WINDOW_MOUSE_CAPTURE) == 0)) {
221  int w, h;
222  SDL_GetWindowSize(window, &w, &h);
223  if (x < 0 || y < 0 || x >= w || y >= h) {
224  inWindow = SDL_FALSE;
225  }
226  }
227 
228 /* Linux doesn't give you mouse events outside your window unless you grab
229  the pointer.
230 
231  Windows doesn't give you mouse events outside your window unless you call
232  SetCapture().
233 
234  Both of these are slightly scary changes, so for now we'll punt and if the
235  mouse leaves the window you'll lose mouse focus and reset button state.
236 */
237 #ifdef SUPPORT_DRAG_OUTSIDE_WINDOW
238  if (!inWindow && !buttonstate) {
239 #else
240  if (!inWindow) {
241 #endif
242  if (window == mouse->focus) {
243 #ifdef DEBUG_MOUSE
244  printf("Mouse left window, synthesizing move & focus lost event\n");
245 #endif
246  SDL_PrivateSendMouseMotion(window, mouse->mouseID, 0, x, y);
248  }
249  return SDL_FALSE;
250  }
251 
252  if (window != mouse->focus) {
253 #ifdef DEBUG_MOUSE
254  printf("Mouse entered window, synthesizing focus gain & move event\n");
255 #endif
256  SDL_SetMouseFocus(window);
257  SDL_PrivateSendMouseMotion(window, mouse->mouseID, 0, x, y);
258  }
259  return SDL_TRUE;
260 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
static int SDL_PrivateSendMouseMotion(SDL_Window *window, SDL_MouseID mouseID, int relative, int x, int y)
Definition: SDL_mouse.c:291
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
SDL_Window * focus
Definition: SDL_mouse_c.h:77
GLfloat GLfloat GLfloat GLfloat h
void SDL_SetMouseFocus(SDL_Window *window)
Definition: SDL_mouse.c:177
SDL_MouseID mouseID
Definition: SDL_mouse_c.h:76
#define SDL_GetWindowSize
GLubyte GLubyte GLubyte GLubyte w
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
#define NULL
Definition: begin_code.h:164
SDL_bool
Definition: SDL_stdinc.h:161
Uint32 flags
Definition: SDL_sysvideo.h:83

§ SDL_WarpMouseGlobal()

int SDL_WarpMouseGlobal ( int  x,
int  y 
)

Moves the mouse to the given position in global screen space.

Parameters
xThe x coordinate
yThe y coordinate
Returns
0 on success, -1 on error (usually: unsupported by a platform).
Note
This function generates a mouse motion event

Definition at line 702 of file SDL_mouse.c.

References SDL_GetMouse(), SDL_Unsupported, and SDL_Mouse::WarpMouseGlobal.

703 {
704  SDL_Mouse *mouse = SDL_GetMouse();
705 
706  if (mouse->WarpMouseGlobal) {
707  return mouse->WarpMouseGlobal(x, y);
708  }
709 
710  return SDL_Unsupported();
711 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
int(* WarpMouseGlobal)(int x, int y)
Definition: SDL_mouse_c.h:64
#define SDL_Unsupported()
Definition: SDL_error.h:53

§ SDL_WarpMouseInWindow()

void SDL_WarpMouseInWindow ( SDL_Window window,
int  x,
int  y 
)

Moves the mouse to the given position within the window.

Parameters
windowThe window to move the mouse into, or NULL for the current mouse focus
xThe x coordinate within the window
yThe y coordinate within the window
Note
This function generates a mouse motion event

Definition at line 682 of file SDL_mouse.c.

References SDL_Mouse::focus, SDL_Mouse::mouseID, NULL, SDL_GetMouse(), SDL_SendMouseMotion(), and SDL_Mouse::WarpMouse.

Referenced by SDL_PrivateSendMouseMotion(), and SDL_SetRelativeMouseMode().

683 {
684  SDL_Mouse *mouse = SDL_GetMouse();
685 
686  if (window == NULL) {
687  window = mouse->focus;
688  }
689 
690  if (window == NULL) {
691  return;
692  }
693 
694  if (mouse->WarpMouse) {
695  mouse->WarpMouse(window, x, y);
696  } else {
697  SDL_SendMouseMotion(window, mouse->mouseID, 0, x, y);
698  }
699 }
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:144
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
SDL_Window * focus
Definition: SDL_mouse_c.h:77
SDL_MouseID mouseID
Definition: SDL_mouse_c.h:76
int SDL_SendMouseMotion(SDL_Window *window, SDL_MouseID mouseID, int relative, int x, int y)
Definition: SDL_mouse.c:263
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
#define NULL
Definition: begin_code.h:164
void(* WarpMouse)(SDL_Window *window, int x, int y)
Definition: SDL_mouse_c.h:61

§ ShouldUseRelativeModeWarp()

static SDL_bool ShouldUseRelativeModeWarp ( SDL_Mouse mouse)
static

Definition at line 714 of file SDL_mouse.c.

References SDL_assert, SDL_FALSE, SDL_GetHintBoolean, SDL_HINT_MOUSE_RELATIVE_MODE_WARP, SDL_TRUE, SDL_Mouse::SetRelativeMouseMode, and SDL_Mouse::WarpMouse.

Referenced by SDL_SetRelativeMouseMode().

715 {
716  if (!mouse->SetRelativeMouseMode) {
717  SDL_assert(mouse->WarpMouse); /* Need this functionality for relative mode warp implementation */
718  return SDL_TRUE;
719  }
720 
722 }
int(* SetRelativeMouseMode)(SDL_bool enabled)
Definition: SDL_mouse_c.h:67
#define SDL_GetHintBoolean
#define SDL_assert(condition)
Definition: SDL_assert.h:169
void(* WarpMouse)(SDL_Window *window, int x, int y)
Definition: SDL_mouse_c.h:61
#define SDL_HINT_MOUSE_RELATIVE_MODE_WARP
A variable controlling whether relative mouse mode is implemented using mouse warping.
Definition: SDL_hints.h:294

Variable Documentation

§ SDL_mouse

SDL_Mouse SDL_mouse
static

Definition at line 35 of file SDL_mouse.c.

Referenced by SDL_GetMouse().