mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-11-03 17:24:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
38a301a3f93eb8384bd99a0dad2c9eb2c8ccc220
SDL/test/testcustomcursor.c
Sam Lantinga 2ba76dbe80 Simplified SDL_Surface 
SDL_Surface has been simplified and internal details are no longer in the public structure.

The `format` member of SDL_Surface is now an enumerated pixel format value. You can get the full details of the pixel format by calling `SDL_GetPixelFormatDetails(surface->format)`. You can get the palette associated with the surface by calling SDL_GetSurfacePalette(). You can get the clip rectangle by calling SDL_GetSurfaceClipRect().

SDL_PixelFormat has been renamed SDL_PixelFormatDetails and just describes the pixel format, it does not include a palette for indexed pixel types.

SDL_PixelFormatEnum has been renamed SDL_PixelFormat and is used instead of Uint32 for API functions that refer to pixel format by enumerated value.

SDL_MapRGB(), SDL_MapRGBA(), SDL_GetRGB(), and SDL_GetRGBA() take an optional palette parameter for indexed color lookups.
2024-07-10 00:48:18 -07:00

430 lines
13 KiB
C
Raw Blame History

/*
Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely.
*/
#include <SDL3/SDL_test_common.h>
#include <SDL3/SDL_main.h>
#ifdef SDL_PLATFORM_EMSCRIPTEN
#include <emscripten/emscripten.h>
#endif
#include <stdlib.h>
/* Stolen from the mailing list */
/* Creates a new mouse cursor from an XPM */
/* XPM */
static const char *arrow[] = {
/* width height num_colors chars_per_pixel */
" 32 32 3 1",
/* colors */
"X c #000000",
". c #ffffff",
" c None",
/* pixels */
"X ",
"XX ",
"X.X ",
"X..X ",
"X...X ",
"X....X ",
"X.....X ",
"X......X ",
"X.......X ",
"X........X ",
"X.....XXXXX ",
"X..X..X ",
"X.X X..X ",
"XX X..X ",
"X X..X ",
" X..X ",
" X..X ",
" X..X ",
" XX ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
"0,0"
};
static const char *cross[] = {
/* width height num_colors chars_per_pixel */
" 32 32 3 1",
/* colors */
"o c #000000",
". c #ffffff",
" c None",
/* pixels */
" ",
" ",
" ",
" ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oooooooooooooooooooooooo ",
" oooooooooooooooooooooooo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" oo ",
" ",
" ",
" ",
" ",
"0,0"
};
static SDL_Cursor *
init_color_cursor(const char *file)
{
SDL_Cursor *cursor = NULL;
SDL_Surface *surface = SDL_LoadBMP(file);
if (surface) {
if (SDL_GetSurfacePalette(surface)) {
const Uint8 bpp = SDL_BITSPERPIXEL(surface->format);
const Uint8 mask = (1 << bpp) - 1;
if (SDL_PIXELORDER(surface->format) == SDL_BITMAPORDER_4321)
SDL_SetSurfaceColorKey(surface, 1, (*(Uint8 *)surface->pixels) & mask);
else
SDL_SetSurfaceColorKey(surface, 1, ((*(Uint8 *)surface->pixels) >> (8 - bpp)) & mask);
} else {
switch (SDL_BITSPERPIXEL(surface->format)) {
case 15:
SDL_SetSurfaceColorKey(surface, 1, (*(Uint16 *)surface->pixels) & 0x00007FFF);
break;
case 16:
SDL_SetSurfaceColorKey(surface, 1, *(Uint16 *)surface->pixels);
break;
case 24:
SDL_SetSurfaceColorKey(surface, 1, (*(Uint32 *)surface->pixels) & 0x00FFFFFF);
break;
case 32:
SDL_SetSurfaceColorKey(surface, 1, *(Uint32 *)surface->pixels);
break;
}
}
cursor = SDL_CreateColorCursor(surface, 0, 0);
SDL_DestroySurface(surface);
}
return cursor;
}
static SDL_Cursor *
init_system_cursor(const char *image[])
{
int i, row, col;
Uint8 data[4 * 32];
Uint8 mask[4 * 32];
int hot_x = 0;
int hot_y = 0;
i = -1;
for (row = 0; row < 32; ++row) {
for (col = 0; col < 32; ++col) {
if (col % 8) {
data[i] <<= 1;
mask[i] <<= 1;
} else {
++i;
data[i] = mask[i] = 0;
}
switch (image[4 + row][col]) {
case 'X':
data[i] |= 0x01;
mask[i] |= 0x01;
break;
case '.':
mask[i] |= 0x01;
break;
case 'o':
data[i] |= 0x01;
break;
case ' ':
break;
}
}
}
(void)SDL_sscanf(image[4 + row], "%d,%d", &hot_x, &hot_y);
return SDL_CreateCursor(data, mask, 32, 32, hot_x, hot_y);
}
static SDLTest_CommonState *state;
static int done;
static SDL_Cursor *cursors[3 + SDL_NUM_SYSTEM_CURSORS];
static SDL_SystemCursor cursor_types[3 + SDL_NUM_SYSTEM_CURSORS];
static int num_cursors;
static int current_cursor;
static SDL_bool show_cursor;
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
static void
quit(int rc)
{
SDLTest_CommonQuit(state);
/* Let 'main()' return normally */
if (rc != 0) {
exit(rc);
}
}
static void loop(void)
{
int i;
SDL_Event event;
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
if (event.button.button == SDL_BUTTON_LEFT) {
if (num_cursors == 0) {
continue;
}
++current_cursor;
if (current_cursor == num_cursors) {
current_cursor = 0;
}
SDL_SetCursor(cursors[current_cursor]);
switch ((int)cursor_types[current_cursor]) {
case (SDL_SystemCursor)-1:
SDL_Log("Custom cursor");
break;
case SDL_SYSTEM_CURSOR_DEFAULT:
SDL_Log("Default");
break;
case SDL_SYSTEM_CURSOR_TEXT:
SDL_Log("Text");
break;
case SDL_SYSTEM_CURSOR_WAIT:
SDL_Log("Wait");
break;
case SDL_SYSTEM_CURSOR_CROSSHAIR:
SDL_Log("Crosshair");
break;
case SDL_SYSTEM_CURSOR_PROGRESS:
SDL_Log("Progress: Small wait cursor (or Wait if not available)");
break;
case SDL_SYSTEM_CURSOR_NWSE_RESIZE:
SDL_Log("Double arrow pointing northwest and southeast");
break;
case SDL_SYSTEM_CURSOR_NESW_RESIZE:
SDL_Log("Double arrow pointing northeast and southwest");
break;
case SDL_SYSTEM_CURSOR_EW_RESIZE:
SDL_Log("Double arrow pointing west and east");
break;
case SDL_SYSTEM_CURSOR_NS_RESIZE:
SDL_Log("Double arrow pointing north and south");
break;
case SDL_SYSTEM_CURSOR_MOVE:
SDL_Log("Move: Four pointed arrow pointing north, south, east, and west");
break;
case SDL_SYSTEM_CURSOR_NOT_ALLOWED:
SDL_Log("Not Allowed: Slashed circle or crossbones");
break;
case SDL_SYSTEM_CURSOR_POINTER:
SDL_Log("Pointer: Hand");
break;
case SDL_SYSTEM_CURSOR_NW_RESIZE:
SDL_Log("Window resize top-left");
break;
case SDL_SYSTEM_CURSOR_N_RESIZE:
SDL_Log("Window resize top");
break;
case SDL_SYSTEM_CURSOR_NE_RESIZE:
SDL_Log("Window resize top-right");
break;
case SDL_SYSTEM_CURSOR_E_RESIZE:
SDL_Log("Window resize right");
break;
case SDL_SYSTEM_CURSOR_SE_RESIZE:
SDL_Log("Window resize bottom-right");
break;
case SDL_SYSTEM_CURSOR_S_RESIZE:
SDL_Log("Window resize bottom");
break;
case SDL_SYSTEM_CURSOR_SW_RESIZE:
SDL_Log("Window resize bottom-left");
break;
case SDL_SYSTEM_CURSOR_W_RESIZE:
SDL_Log("Window resize left");
break;
default:
SDL_Log("UNKNOWN CURSOR TYPE, FIX THIS PROGRAM.");
break;
}
} else {
show_cursor = !show_cursor;
if (show_cursor) {
SDL_ShowCursor();
} else {
SDL_HideCursor();
}
}
}
}
for (i = 0; i < state->num_windows; ++i) {
SDL_Renderer *renderer = state->renderers[i];
SDL_FRect rect;
int x, y, row;
int window_w = 0, window_h = 0;
SDL_GetWindowSize(state->windows[i], &window_w, &window_h);
rect.w = 128.0f;
rect.h = 128.0f;
for (y = 0, row = 0; y < window_h; y += (int)rect.h, ++row) {
SDL_bool black = ((row % 2) == 0) ? SDL_TRUE : SDL_FALSE;
for (x = 0; x < window_w; x += (int)rect.w) {
rect.x = (float)x;
rect.y = (float)y;
if (black) {
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
} else {
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
}
SDL_RenderFillRect(renderer, &rect);
black = !black;
}
}
SDL_RenderPresent(renderer);
}
#ifdef SDL_PLATFORM_EMSCRIPTEN
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
int main(int argc, char *argv[])
{
int i;
const char *color_cursor = NULL;
SDL_Cursor *cursor;
/* Enable standard application logging */
SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if (!state) {
return 1;
}
for (i = 1; i < argc;) {
int consumed;
consumed = SDLTest_CommonArg(state, i);
if (consumed == 0) {
color_cursor = argv[i];
break;
}
if (consumed < 0) {
SDLTest_CommonLogUsage(state, argv[0], NULL);
quit(1);
}
i += consumed;
}
if (!SDLTest_CommonInit(state)) {
quit(2);
}
num_cursors = 0;
if (color_cursor) {
cursor = init_color_cursor(color_cursor);
if (cursor) {
cursors[num_cursors] = cursor;
cursor_types[num_cursors] = (SDL_SystemCursor)-1;
num_cursors++;
}
}
cursor = init_system_cursor(arrow);
if (cursor) {
cursors[num_cursors] = cursor;
cursor_types[num_cursors] = (SDL_SystemCursor)-1;
num_cursors++;
}
cursor = init_system_cursor(cross);
if (cursor) {
cursors[num_cursors] = cursor;
cursor_types[num_cursors] = (SDL_SystemCursor)-1;
num_cursors++;
}
for (i = 0; i < SDL_NUM_SYSTEM_CURSORS; ++i) {
cursor = SDL_CreateSystemCursor((SDL_SystemCursor)i);
if (cursor) {
cursors[num_cursors] = cursor;
cursor_types[num_cursors] = i;
num_cursors++;
}
}
if (num_cursors > 0) {
SDL_SetCursor(cursors[0]);
}
show_cursor = SDL_CursorVisible();
/* Main render loop */
done = 0;
#ifdef SDL_PLATFORM_EMSCRIPTEN
emscripten_set_main_loop(loop, 0, 1);
#else
while (!done) {
loop();
}
#endif
for (i = 0; i < num_cursors; ++i) {
SDL_DestroyCursor(cursors[i]);
}
quit(0);
/* keep the compiler happy ... */
return 0;
}
Reference in New Issue View Git Blame Copy Permalink