src/video/psp/SDL_pspvideo.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 02 Feb 2014 00:53:27 -0800
changeset 8149 681eb46b8ac4
parent 8093 b43765095a6f
child 9325 4f7a9123393a
permissions -rw-r--r--
Fixed bug 2374 - Update copyright for 2014...

Is it that time already??
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 
    22 #include "../../SDL_internal.h"
    23 
    24 #if SDL_VIDEO_DRIVER_PSP
    25 
    26 /* SDL internals */
    27 #include "../SDL_sysvideo.h"
    28 #include "SDL_version.h"
    29 #include "SDL_syswm.h"
    30 #include "SDL_loadso.h"
    31 #include "SDL_events.h"
    32 #include "../../events/SDL_mouse_c.h"
    33 #include "../../events/SDL_keyboard_c.h"
    34 
    35 
    36 
    37 /* PSP declarations */
    38 #include "SDL_pspvideo.h"
    39 #include "SDL_pspevents_c.h"
    40 #include "SDL_pspgl_c.h"
    41 
    42 /* unused
    43 static SDL_bool PSP_initialized = SDL_FALSE;
    44 */
    45 static int
    46 PSP_Available(void)
    47 {
    48     return 1;
    49 }
    50 
    51 static void
    52 PSP_Destroy(SDL_VideoDevice * device)
    53 {
    54 /*    SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata; */
    55 
    56     if (device->driverdata != NULL) {
    57         device->driverdata = NULL;
    58     }
    59 }
    60 
    61 static SDL_VideoDevice *
    62 PSP_Create()
    63 {
    64     SDL_VideoDevice *device;
    65     SDL_VideoData *phdata;
    66     SDL_GLDriverData *gldata;
    67     int status;
    68 
    69     /* Check if pandora could be initialized */
    70     status = PSP_Available();
    71     if (status == 0) {
    72         /* PSP could not be used */
    73         return NULL;
    74     }
    75 
    76     /* Initialize SDL_VideoDevice structure */
    77     device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
    78     if (device == NULL) {
    79         SDL_OutOfMemory();
    80         return NULL;
    81     }
    82 
    83     /* Initialize internal Pandora specific data */
    84     phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
    85     if (phdata == NULL) {
    86         SDL_OutOfMemory();
    87         SDL_free(device);
    88         return NULL;
    89     }
    90 
    91         gldata = (SDL_GLDriverData *) SDL_calloc(1, sizeof(SDL_GLDriverData));
    92     if (gldata == NULL) {
    93         SDL_OutOfMemory();
    94         SDL_free(device);
    95         return NULL;
    96     }
    97     device->gl_data = gldata;
    98 
    99     device->driverdata = phdata;
   100 
   101     phdata->egl_initialized = SDL_TRUE;
   102 
   103 
   104     /* Setup amount of available displays and current display */
   105     device->num_displays = 0;
   106 
   107     /* Set device free function */
   108     device->free = PSP_Destroy;
   109 
   110     /* Setup all functions which we can handle */
   111     device->VideoInit = PSP_VideoInit;
   112     device->VideoQuit = PSP_VideoQuit;
   113     device->GetDisplayModes = PSP_GetDisplayModes;
   114     device->SetDisplayMode = PSP_SetDisplayMode;
   115     device->CreateWindow = PSP_CreateWindow;
   116     device->CreateWindowFrom = PSP_CreateWindowFrom;
   117     device->SetWindowTitle = PSP_SetWindowTitle;
   118     device->SetWindowIcon = PSP_SetWindowIcon;
   119     device->SetWindowPosition = PSP_SetWindowPosition;
   120     device->SetWindowSize = PSP_SetWindowSize;
   121     device->ShowWindow = PSP_ShowWindow;
   122     device->HideWindow = PSP_HideWindow;
   123     device->RaiseWindow = PSP_RaiseWindow;
   124     device->MaximizeWindow = PSP_MaximizeWindow;
   125     device->MinimizeWindow = PSP_MinimizeWindow;
   126     device->RestoreWindow = PSP_RestoreWindow;
   127     device->SetWindowGrab = PSP_SetWindowGrab;
   128     device->DestroyWindow = PSP_DestroyWindow;
   129     device->GetWindowWMInfo = PSP_GetWindowWMInfo;
   130     device->GL_LoadLibrary = PSP_GL_LoadLibrary;
   131     device->GL_GetProcAddress = PSP_GL_GetProcAddress;
   132     device->GL_UnloadLibrary = PSP_GL_UnloadLibrary;
   133     device->GL_CreateContext = PSP_GL_CreateContext;
   134     device->GL_MakeCurrent = PSP_GL_MakeCurrent;
   135     device->GL_SetSwapInterval = PSP_GL_SetSwapInterval;
   136     device->GL_GetSwapInterval = PSP_GL_GetSwapInterval;
   137     device->GL_SwapWindow = PSP_GL_SwapWindow;
   138     device->GL_DeleteContext = PSP_GL_DeleteContext;
   139     device->HasScreenKeyboardSupport = PSP_HasScreenKeyboardSupport;
   140     device->ShowScreenKeyboard = PSP_ShowScreenKeyboard;
   141     device->HideScreenKeyboard = PSP_HideScreenKeyboard;
   142     device->IsScreenKeyboardShown = PSP_IsScreenKeyboardShown;
   143 
   144     device->PumpEvents = PSP_PumpEvents;
   145 
   146     return device;
   147 }
   148 
   149 VideoBootStrap PSP_bootstrap = {
   150     "PSP",
   151     "PSP Video Driver",
   152     PSP_Available,
   153     PSP_Create
   154 };
   155 
   156 /*****************************************************************************/
   157 /* SDL Video and Display initialization/handling functions                   */
   158 /*****************************************************************************/
   159 int
   160 PSP_VideoInit(_THIS)
   161 {
   162     SDL_VideoDisplay display;
   163     SDL_DisplayMode current_mode;
   164 
   165     SDL_zero(current_mode);
   166 
   167     current_mode.w = 480;
   168     current_mode.h = 272;
   169 
   170     current_mode.refresh_rate = 60;
   171     /* 32 bpp for default */
   172     current_mode.format = SDL_PIXELFORMAT_ABGR8888;
   173 
   174     current_mode.driverdata = NULL;
   175 
   176     SDL_zero(display);
   177     display.desktop_mode = current_mode;
   178     display.current_mode = current_mode;
   179     display.driverdata = NULL;
   180 
   181     SDL_AddVideoDisplay(&display);
   182 
   183     return 1;
   184 }
   185 
   186 void
   187 PSP_VideoQuit(_THIS)
   188 {
   189 
   190 }
   191 
   192 void
   193 PSP_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
   194 {
   195 
   196 }
   197 
   198 int
   199 PSP_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
   200 {
   201     return 0;
   202 }
   203 #define EGLCHK(stmt)                            \
   204     do {                                        \
   205         EGLint err;                             \
   206                                                 \
   207         stmt;                                   \
   208         err = eglGetError();                    \
   209         if (err != EGL_SUCCESS) {               \
   210             SDL_SetError("EGL error %d", err);  \
   211             return 0;                           \
   212         }                                       \
   213     } while (0)
   214 
   215 int
   216 PSP_CreateWindow(_THIS, SDL_Window * window)
   217 {
   218     SDL_WindowData *wdata;
   219 
   220     /* Allocate window internal data */
   221     wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
   222     if (wdata == NULL) {
   223         return SDL_OutOfMemory();
   224     }
   225 
   226     /* Setup driver data for this window */
   227     window->driverdata = wdata;
   228 
   229 
   230     /* Window has been successfully created */
   231     return 0;
   232 }
   233 
   234 int
   235 PSP_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
   236 {
   237     return -1;
   238 }
   239 
   240 void
   241 PSP_SetWindowTitle(_THIS, SDL_Window * window)
   242 {
   243 }
   244 void
   245 PSP_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
   246 {
   247 }
   248 void
   249 PSP_SetWindowPosition(_THIS, SDL_Window * window)
   250 {
   251 }
   252 void
   253 PSP_SetWindowSize(_THIS, SDL_Window * window)
   254 {
   255 }
   256 void
   257 PSP_ShowWindow(_THIS, SDL_Window * window)
   258 {
   259 }
   260 void
   261 PSP_HideWindow(_THIS, SDL_Window * window)
   262 {
   263 }
   264 void
   265 PSP_RaiseWindow(_THIS, SDL_Window * window)
   266 {
   267 }
   268 void
   269 PSP_MaximizeWindow(_THIS, SDL_Window * window)
   270 {
   271 }
   272 void
   273 PSP_MinimizeWindow(_THIS, SDL_Window * window)
   274 {
   275 }
   276 void
   277 PSP_RestoreWindow(_THIS, SDL_Window * window)
   278 {
   279 }
   280 void
   281 PSP_SetWindowGrab(_THIS, SDL_Window * window, SDL_bool grabbed)
   282 {
   283 
   284 }
   285 void
   286 PSP_DestroyWindow(_THIS, SDL_Window * window)
   287 {
   288 }
   289 
   290 /*****************************************************************************/
   291 /* SDL Window Manager function                                               */
   292 /*****************************************************************************/
   293 SDL_bool
   294 PSP_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
   295 {
   296     if (info->version.major <= SDL_MAJOR_VERSION) {
   297         return SDL_TRUE;
   298     } else {
   299         SDL_SetError("application not compiled with SDL %d.%d\n",
   300                      SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
   301         return SDL_FALSE;
   302     }
   303 
   304     /* Failed to get window manager information */
   305     return SDL_FALSE;
   306 }
   307 
   308 
   309 /* TO Write Me */
   310 SDL_bool PSP_HasScreenKeyboardSupport(_THIS)
   311 {
   312     return SDL_FALSE;
   313 }
   314 void PSP_ShowScreenKeyboard(_THIS, SDL_Window *window)
   315 {
   316 }
   317 void PSP_HideScreenKeyboard(_THIS, SDL_Window *window)
   318 {
   319 }
   320 SDL_bool PSP_IsScreenKeyboardShown(_THIS, SDL_Window *window)
   321 {
   322     return SDL_FALSE;
   323 }
   324 
   325 
   326 #endif /* SDL_VIDEO_DRIVER_PSP */
   327 
   328 /* vi: set ts=4 sw=4 expandtab: */