/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

#ifndef _SDL_sysvideo_h

#define _SDL_sysvideo_h

#include "SDL_mouse.h"

/* The SDL video driver */

typedef struct SDL_Renderer SDL_Renderer;

typedef struct SDL_RenderDriver SDL_RenderDriver;

typedef struct SDL_WindowShaper SDL_WindowShaper;

typedef struct SDL_ShapeDriver SDL_ShapeDriver;

typedef struct SDL_VideoDisplay SDL_VideoDisplay;

typedef struct SDL_VideoDevice SDL_VideoDevice;

/* Define the SDL texture structure */

struct SDL_Texture

{

Uint32 format; /**< The pixel format of the texture */

int access; /**< SDL_TextureAccess */

int w; /**< The width of the texture */

int h; /**< The height of the texture */

int modMode; /**< The texture modulation mode */

};

/* Define the SDL renderer structure */

struct SDL_Renderer

{

int (*ActivateRenderer) (SDL_Renderer * renderer);

int (*DisplayModeChanged) (SDL_Renderer * renderer);

int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);

int (*QueryTexturePixels) (SDL_Renderer * renderer, SDL_Texture * texture,

void **pixels, int *pitch);

int (*SetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Color * colors, int firstcolor,

int ncolors);

int (*GetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,

SDL_Color * colors, int firstcolor,

int ncolors);

int (*SetTextureColorMod) (SDL_Renderer * renderer,

SDL_Texture * texture);

int (*SetTextureAlphaMod) (SDL_Renderer * renderer,

SDL_Texture * texture);

int (*SetTextureBlendMode) (SDL_Renderer * renderer,

SDL_Texture * texture);

int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, const void *pixels,

int pitch);

int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, int markDirty, void **pixels,

int *pitch);

void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);

void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture,

int numrects, const SDL_Rect * rects);

int (*RenderClear) (SDL_Renderer * renderer);

int (*RenderDrawPoints) (SDL_Renderer * renderer, const SDL_Point * points,

int count);

int (*RenderDrawLines) (SDL_Renderer * renderer, const SDL_Point * points,

int count);

int (*RenderDrawRects) (SDL_Renderer * renderer, const SDL_Rect ** rects,

int count);

int (*RenderFillRects) (SDL_Renderer * renderer, const SDL_Rect ** rects,

int count);

int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * srcrect, const SDL_Rect * dstrect);

void (*RenderPresent) (SDL_Renderer * renderer);

void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture);

void (*DestroyRenderer) (SDL_Renderer * renderer);

/* The current renderer info */

SDL_RendererInfo info;

/* The window associated with the renderer */

SDL_Window *window;

/* The list of textures */

SDL_Texture *textures;

};

/* Define the SDL render driver structure */

struct SDL_RenderDriver

{

SDL_Renderer *(*CreateRenderer) (SDL_Window * window, Uint32 flags);

/* Info about the renderer capabilities */

SDL_RendererInfo info;

};

/* Define the SDL window-shaper structure */

struct SDL_WindowShaper

{

/* The window associated with the shaper */

SDL_Window *window;

/* The user's specified coordinates for the window, for once we give it a shape. */

Uint32 userx,usery;

/* The parameters for shape calculation. */

SDL_WindowShapeMode mode;

/* Has this window been assigned a shape? */

SDL_bool hasshape;

void *driverdata;

};

/* Define the SDL shape driver structure */

struct SDL_ShapeDriver

{

SDL_WindowShaper *(*CreateShaper)(SDL_Window * window);

int (*ResizeWindowShape)(SDL_Window *window);

};

struct SDL_Window

{

Uint32 id;

char *title;

int x, y;

int w, h;

Uint32 flags;

SDL_WindowShaper *shaper;

void *userdata;

void *driverdata;

SDL_Window *prev;

SDL_Window *next;

};

#define FULLSCREEN_VISIBLE(W) \

(((W)->flags & SDL_WINDOW_FULLSCREEN) && \

((W)->flags & SDL_WINDOW_SHOWN) && \

!((W)->flags & SDL_WINDOW_MINIMIZED))

/*

* Define the SDL display structure This corresponds to physical monitors

* attached to the system.

struct SDL_VideoDisplay

{

int max_display_modes;

int num_display_modes;

SDL_DisplayMode *display_modes;

SDL_DisplayMode desktop_mode;

SDL_DisplayMode current_mode;

Uint16 *gamma;

Uint16 *saved_gamma; /* (just offset into gamma) */

int num_render_drivers;

SDL_RenderDriver *render_drivers;

/* Define the SDL video driver structure */

#define _THIS SDL_VideoDevice *_this

struct SDL_VideoDevice

{

/* * * */

/* The name of this video driver */

const char *name;

/* * * */

/* Initialization/Query functions */

/*

* Initialize the native video subsystem, filling in the list of

* displays for this driver, returning 0 or -1 if there's an error.

*/

int (*VideoInit) (_THIS);

/*

* Reverse the effects VideoInit() -- called if VideoInit() fails or

* if the application is shutting down the video subsystem.

*/

void (*VideoQuit) (_THIS);

/* * * */

/*

* Display functions

*/

/*

* Get the bounds of a display

*/

int (*GetDisplayBounds) (_THIS, SDL_VideoDisplay * display, SDL_Rect * rect);

/*

* Get a list of the available display modes. e.g.

* SDL_AddDisplayMode(_this->current_display, mode)

*/

/*

* Setting the display mode is independent of creating windows, so

* when the display mode is changed, all existing windows should have

* their data updated accordingly, including the display surfaces

* associated with them.

*/

/* Set the color entries of the display palette */

/* Get the color entries of the display palette */

/* Set the gamma ramp */

/* Get the gamma ramp */

/* * * */

/*

* Window functions

*/

int (*CreateWindow) (_THIS, SDL_Window * window);

int (*CreateWindowFrom) (_THIS, SDL_Window * window, const void *data);

void (*SetWindowTitle) (_THIS, SDL_Window * window);

void (*SetWindowPosition) (_THIS, SDL_Window * window);

void (*SetWindowSize) (_THIS, SDL_Window * window);

void (*ShowWindow) (_THIS, SDL_Window * window);

void (*HideWindow) (_THIS, SDL_Window * window);

void (*RaiseWindow) (_THIS, SDL_Window * window);

void (*MaximizeWindow) (_THIS, SDL_Window * window);

void (*MinimizeWindow) (_THIS, SDL_Window * window);

void (*RestoreWindow) (_THIS, SDL_Window * window);

void (*SetWindowGrab) (_THIS, SDL_Window * window);

void (*DestroyWindow) (_THIS, SDL_Window * window);

/* * * */

/*

* Shaped-window functions

*/

SDL_ShapeDriver shape_driver;

/* Get some platform dependent window information */

SDL_bool(*GetWindowWMInfo) (_THIS, SDL_Window * window,

struct SDL_SysWMinfo * info);

/* * * */

/*

* OpenGL support

*/

int (*GL_LoadLibrary) (_THIS, const char *path);

void *(*GL_GetProcAddress) (_THIS, const char *proc);

SDL_GLContext(*GL_CreateContext) (_THIS, SDL_Window * window);

int (*GL_MakeCurrent) (_THIS, SDL_Window * window, SDL_GLContext context);

int (*GL_SetSwapInterval) (_THIS, int interval);

int (*GL_GetSwapInterval) (_THIS);

void (*GL_SwapWindow) (_THIS, SDL_Window * window);

void (*GL_DeleteContext) (_THIS, SDL_GLContext context);

/* * * */

/*

* Event manager functions

*/

void (*PumpEvents) (_THIS);

/* Suspend the screensaver */

void (*SuspendScreenSaver) (_THIS);

/* Text input */

void (*StartTextInput) (_THIS);

void (*StopTextInput) (_THIS);

void (*SetTextInputRect) (_THIS, SDL_Rect *rect);

/* Clipboard */

int (*SetClipboardText) (_THIS, const char *text);

char * (*GetClipboardText) (_THIS);

SDL_bool (*HasClipboardText) (_THIS);

/* * * */

/* Data common to all drivers */

int num_displays;

SDL_VideoDisplay *displays;

int current_display;

Uint8 window_magic;

Uint8 texture_magic;

/* * * */

/* Data used by the GL drivers */

struct

{

int red_size;

int green_size;

int blue_size;

int alpha_size;

int depth_size;

int buffer_size;

int stencil_size;

int double_buffer;

int accum_red_size;

int accum_green_size;

int accum_blue_size;

int accum_alpha_size;

int stereo;

int multisamplebuffers;

int multisamplesamples;

int accelerated;

int major_version;

int minor_version;

int retained_backing;

int driver_loaded;

char driver_path[256];

void *dll_handle;

} gl_config;

/* * * */

/* Data private to this driver */

void *driverdata;

struct SDL_GLDriverData *gl_data;

#if SDL_VIDEO_DRIVER_PANDORA

struct SDL_PrivateGLESData *gles_data;

#endif

/* * * */

/* The function used to dispose of this structure */

void (*free) (_THIS);

};

typedef struct VideoBootStrap

{

const char *name;

const char *desc;

int (*available) (void);

SDL_VideoDevice *(*create) (int devindex);

} VideoBootStrap;

#if SDL_VIDEO_DRIVER_COCOA

extern VideoBootStrap COCOA_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_X11

extern VideoBootStrap X11_bootstrap;

#endif

extern VideoBootStrap DirectFB_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_WINDOWS

extern VideoBootStrap WINDOWS_bootstrap;

extern VideoBootStrap BWINDOW_bootstrap;

#endif

extern VideoBootStrap photon_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_QNXGF

extern VideoBootStrap qnxgf_bootstrap;

extern VideoBootStrap EPOC_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_UIKIT

extern VideoBootStrap UIKIT_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_DUMMY

extern VideoBootStrap DUMMY_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_NDS

extern VideoBootStrap NDS_bootstrap;

#endif

#if SDL_VIDEO_DRIVER_PANDORA

extern VideoBootStrap PND_bootstrap;

#if SDL_VIDEO_DRIVER_ANDROID

extern VideoBootStrap Android_bootstrap;

#endif

#define SDL_CurrentDisplay (&_this->displays[_this->current_display])

#define SDL_CurrentRenderer (SDL_CurrentDisplay->current_renderer)

extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);

extern int SDL_AddVideoDisplay(const SDL_VideoDisplay * display);

extern SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode * mode);

extern int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay * display);

extern int SDL_GetDisplayModeForDisplay(SDL_VideoDisplay * display, int index, SDL_DisplayMode * mode);

extern int SDL_GetDesktopDisplayModeForDisplay(SDL_VideoDisplay * display, SDL_DisplayMode * mode);

extern int SDL_GetCurrentDisplayModeForDisplay(SDL_VideoDisplay * display, SDL_DisplayMode * mode);

extern SDL_DisplayMode * SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode * mode, SDL_DisplayMode * closest);

extern int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay * display, const SDL_DisplayMode * mode);

extern int SDL_SetPaletteForDisplay(SDL_VideoDisplay * display, const SDL_Color * colors, int firstcolor, int ncolors);

extern int SDL_GetPaletteForDisplay(SDL_VideoDisplay * display, SDL_Color * colors, int firstcolor, int ncolors);

extern int SDL_SetGammaRampForDisplay(SDL_VideoDisplay * display, const Uint16 * red, const Uint16 * green, const Uint16 * blue);

extern int SDL_GetGammaRampForDisplay(SDL_VideoDisplay * display, Uint16 * red, Uint16 * green, Uint16 * blue);

extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);

extern void SDL_OnWindowShown(SDL_Window * window);

extern void SDL_OnWindowHidden(SDL_Window * window);

extern void SDL_OnWindowResized(SDL_Window * window);

extern void SDL_OnWindowMinimized(SDL_Window * window);

extern void SDL_OnWindowRestored(SDL_Window * window);

extern void SDL_OnWindowFocusGained(SDL_Window * window);

extern void SDL_OnWindowFocusLost(SDL_Window * window);

/* vi: set ts=4 sw=4 expandtab: */