xorg-server-1.4/hw/kdrive/sdl/sdl.c

   1 /*
   2  * Copyright © 2004 PillowElephantBadgerBankPond
   3
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of PillowElephantBadgerBankPond not be used in
   9  * advertising or publicity pertaining to distribution of the software without
  10  * specific, written prior permission.  PillowElephantBadgerBankPond makes no
  11  * representations about the suitability of this software for any purpose.  It
  12  * is provided "as is" without express or implied warranty.
  13  *
  14  * PillowElephantBadgerBankPond DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL PillowElephantBadgerBankPond BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  20  * PERFORMANCE OF THIS SOFTWARE.
  21  *
  22  * It's really not my fault - see it was the elephants!!
  23  *      - jaymz
  24  *
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 #include "kdrive-config.h"
  28 #endif
  29 #include "kdrive.h"
  30 #include <SDL/SDL.h>
  31 #include <X11/keysym.h>
  32
  33 static void xsdlFini(void);
  34 static Bool sdlScreenInit(KdScreenInfo *screen);
  35 static Bool sdlFinishInitScreen(ScreenPtr pScreen);
  36 static Bool sdlCreateRes(ScreenPtr pScreen);
  37
  38 static void sdlKeyboardFini(KdKeyboardInfo *ki);
  39 static Bool sdlKeyboardInit(KdKeyboardInfo *ki);
  40
  41 static Bool sdlMouseInit(KdPointerInfo *pi);
  42 static void sdlMouseFini(KdPointerInfo *pi);
  43
  44 void *sdlShadowWindow (ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, CARD32 *size, void *closure);
  45 void sdlShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
  46
  47 void sdlTimer(void);
  48
  49 KdKeyboardInfo *sdlKeyboard = NULL;
  50 KdPointerInfo *sdlPointer = NULL;
  51
  52 KeySym sdlKeymap[]={
  53         0,                      /* 8 */
  54         0,
  55         XK_Escape, NoSymbol,    /* escape */
  56         XK_1, XK_exclam,
  57         XK_2, XK_at,
  58         XK_3, XK_numbersign,
  59         XK_4, XK_dollar,
  60         XK_5, XK_percent,
  61         XK_6, XK_asciicircum,
  62         XK_7, XK_ampersand,
  63         XK_8, XK_asterisk,
  64         XK_9, XK_parenleft,
  65         XK_0, XK_parenright,
  66         XK_minus, XK_underscore,
  67         XK_equal, XK_plus,
  68         XK_BackSpace, NoSymbol,         /* backspace */
  69         XK_Tab, NoSymbol,
  70         XK_q, XK_Q,
  71         XK_w, XK_W,
  72         XK_e, XK_E,
  73         XK_r, XK_R,
  74         XK_t, XK_T,
  75         XK_y, XK_Y,
  76         XK_u, XK_U,
  77         XK_i, XK_I,
  78         XK_o, XK_O,
  79         XK_p, XK_P,
  80         XK_bracketleft, XK_braceleft,           /* [, { */
  81         XK_bracketright, XK_braceright,         /* ]. } */
  82         XK_Return, NoSymbol,
  83         XK_Control_L, NoSymbol,
  84         XK_a, XK_A,
  85         XK_s, XK_S,
  86         XK_d, XK_D,
  87         XK_f, XK_F,
  88         XK_g, XK_G,
  89         XK_h, XK_H,
  90         XK_j, XK_J,
  91         XK_k, XK_K,
  92         XK_l, XK_L,
  93         XK_semicolon, XK_colon,
  94         XK_apostrophe, XK_quotedbl,
  95         XK_grave, XK_asciitilde,
  96         XK_Shift_L, NoSymbol,
  97         XK_backslash, XK_bar,
  98         XK_z, XK_z,
  99         XK_x, XK_X,
 100         XK_c, XK_C,
 101         XK_v, XK_V,
 102         XK_b, XK_B,
 103         XK_n, XK_N,
 104         XK_m, XK_M,
 105         XK_comma, XK_less,
 106         XK_period, XK_greater,
 107         XK_slash, XK_question,
 108         XK_Shift_R, NoSymbol,
 109         XK_KP_Multiply, NoSymbol,
 110         XK_Meta_L, XK_Alt_L,
 111         XK_space, NoSymbol,
 112         XK_Caps_Lock, NoSymbol,
 113         XK_F1, NoSymbol,
 114         XK_F2, NoSymbol,
 115         XK_F3, NoSymbol,
 116         XK_F4, NoSymbol,
 117         XK_F5, NoSymbol,
 118         XK_F6, NoSymbol,
 119         XK_F7, NoSymbol,
 120         XK_F8, NoSymbol,
 121         XK_F9, NoSymbol,
 122         XK_F10, NoSymbol,
 123         XK_Num_Lock, NoSymbol,
 124         XK_Scroll_Lock, NoSymbol,
 125         XK_KP_Home, XK_KP_7,
 126         XK_KP_Up, XK_KP_8,
 127         XK_KP_Page_Up, XK_KP_9,
 128         XK_KP_Subtract, NoSymbol,
 129         XK_KP_Left, XK_KP_4,
 130         XK_KP_5, NoSymbol,
 131         XK_KP_Right, XK_KP_6,
 132         XK_KP_Add, NoSymbol,
 133         XK_KP_End, XK_KP_1,
 134         XK_KP_Down, XK_KP_2,
 135         XK_KP_Page_Down, XK_KP_3,
 136         XK_KP_Insert, XK_KP_0,
 137         XK_KP_Delete, XK_KP_Decimal,
 138         NoSymbol, NoSymbol,             /* 92 */
 139         NoSymbol, NoSymbol,             /* 93 */
 140         NoSymbol, NoSymbol,             /* 94 */
 141         XK_F11, NoSymbol,               /* 95 */
 142         XK_F12, NoSymbol,               /* 96 */
 143         XK_Home, NoSymbol,              /* 97 */
 144         XK_Up, NoSymbol,                /* 98 */
 145         XK_Page_Up, NoSymbol,           /* 99 */
 146         XK_Left, NoSymbol,              /* 100 */
 147         NoSymbol, NoSymbol,             /* 101 */
 148         XK_Right, NoSymbol,             /* 102 */
 149         NoSymbol, NoSymbol,             /* 103 */
 150         XK_Down, NoSymbol,              /* 104 */
 151         XK_Page_Down, NoSymbol,                 /* 105 */
 152         XK_Insert, NoSymbol,            /* 106 */
 153         NoSymbol, NoSymbol,             /* 107 */
 154         NoSymbol, NoSymbol,             /* 108 */
 155         XK_Meta_R, XK_Alt_R,            /* 109 */
 156         XK_Pause, XK_Break,             /* 110 */
 157         XK_Sys_Req, XK_Print,           /* 111 */
 158         NoSymbol, NoSymbol,             /* 112 */
 159         XK_Control_R, NoSymbol,         /* 113 */
 160         NoSymbol, NoSymbol,             /* 114 */
 161         XK_Super_L, NoSymbol,           /* 115 */
 162         XK_Super_R, NoSymbol,           /* 116 */
 163         XK_Menu, NoSymbol,              /* 117 */
 164         NoSymbol, NoSymbol              /* 118 */
 165 };
 166
 167 KdKeyboardDriver sdlKeyboardDriver = {
 168     .name = "keyboard",
 169     .Init = sdlKeyboardInit,
 170     .Fini = sdlKeyboardFini,
 171 };
 172
 173 KdPointerDriver sdlMouseDriver = {
 174     .name = "mouse",
 175     .Init = sdlMouseInit,
 176     .Fini = sdlMouseFini,
 177 };
 178
 179
 180 KdCardFuncs sdlFuncs = {
 181     .scrinit = sdlScreenInit,   /* scrinit */
 182     .finishInitScreen = sdlFinishInitScreen, /* finishInitScreen */
 183     .createRes = sdlCreateRes,  /* createRes */
 184 };
 185
 186 int mouseState=0;
 187
 188 struct SdlDriver
 189 {
 190         SDL_Surface *screen;
 191 };
 192
 193
 194
 195 static Bool sdlScreenInit(KdScreenInfo *screen)
 196 {
 197         struct SdlDriver *sdlDriver=calloc(1, sizeof(struct SdlDriver));
 198 #ifdef DEBUG
 199         printf("sdlScreenInit()\n");
 200 #endif
 201         if (!screen->width || !screen->height)
 202         {
 203                 screen->width = 640;
 204                 screen->height = 480;
 205         }
 206         if (!screen->fb[0].depth)
 207                 screen->fb[0].depth = 4;
 208 #ifdef DEBUG
 209         printf("Attempting for %dx%d/%dbpp mode\n", screen->width, screen->height, screen->fb[0].depth);
 210 #endif
 211         sdlDriver->screen=SDL_SetVideoMode(screen->width, screen->height, screen->fb[0].depth, 0);
 212         if(sdlDriver->screen==NULL)
 213                 return FALSE;
 214 #ifdef DEBUG
 215         printf("Set %dx%d/%dbpp mode\n", sdlDriver->screen->w, sdlDriver->screen->h, sdlDriver->screen->format->BitsPerPixel);
 216 #endif
 217         screen->width=sdlDriver->screen->w;
 218         screen->height=sdlDriver->screen->h;
 219         screen->fb[0].depth=sdlDriver->screen->format->BitsPerPixel;
 220         screen->fb[0].visuals=(1<<TrueColor);
 221         screen->fb[0].redMask=sdlDriver->screen->format->Rmask;
 222         screen->fb[0].greenMask=sdlDriver->screen->format->Gmask;
 223         screen->fb[0].blueMask=sdlDriver->screen->format->Bmask;
 224         screen->fb[0].bitsPerPixel=sdlDriver->screen->format->BitsPerPixel;
 225         screen->rate=60;
 226         screen->memory_base=(CARD8 *)sdlDriver->screen->pixels;
 227         screen->memory_size=0;
 228         screen->off_screen_base=0;
 229         screen->driver=sdlDriver;
 230         screen->fb[0].byteStride=(sdlDriver->screen->w*sdlDriver->screen->format->BitsPerPixel)/8;
 231         screen->fb[0].pixelStride=sdlDriver->screen->w;
 232         screen->fb[0].frameBuffer=(CARD8 *)sdlDriver->screen->pixels;
 233         SDL_WM_SetCaption("Freedesktop.org X server (SDL)", NULL);
 234         return TRUE;
 235 }
 236
 237 void sdlShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf)
 238 {
 239         KdScreenPriv(pScreen);
 240         KdScreenInfo *screen = pScreenPriv->screen;
 241         struct SdlDriver *sdlDriver=screen->driver;
 242 #ifdef DEBUG
 243         printf("Shadow update()\n");
 244 #endif
 245         if(SDL_MUSTLOCK(sdlDriver->screen))
 246         {
 247                 if(SDL_LockSurface(sdlDriver->screen)<0)
 248                 {
 249 #ifdef DEBUG
 250                         printf("Couldn't lock SDL surface - d'oh!\n");
 251 #endif
 252                         return;
 253                 }
 254         }
 255
 256         if(SDL_MUSTLOCK(sdlDriver->screen))
 257                 SDL_UnlockSurface(sdlDriver->screen);
 258         SDL_UpdateRect(sdlDriver->screen, 0, 0, sdlDriver->screen->w, sdlDriver->screen->h);
 259 }
 260
 261
 262 void *sdlShadowWindow (ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, CARD32 *size, void *closure)
 263 {
 264         KdScreenPriv(pScreen);
 265         KdScreenInfo *screen = pScreenPriv->screen;
 266         struct SdlDriver *sdlDriver=screen->driver;
 267         *size=(sdlDriver->screen->w*sdlDriver->screen->format->BitsPerPixel)/8;
 268 #ifdef DEBUG
 269         printf("Shadow window()\n");
 270 #endif
 271         return (void *)((CARD8 *)sdlDriver->screen->pixels + row * (*size) + offset);
 272 }
 273
 274
 275 static Bool sdlCreateRes(ScreenPtr pScreen)
 276 {
 277         KdScreenPriv(pScreen);
 278         KdScreenInfo *screen = pScreenPriv->screen;
 279         KdShadowFbAlloc(screen, 0, FALSE);
 280         KdShadowSet(pScreen, RR_Rotate_0, sdlShadowUpdate, sdlShadowWindow);
 281         return TRUE;
 282 }
 283
 284 static Bool sdlFinishInitScreen(ScreenPtr pScreen)
 285 {
 286         if (!shadowSetup (pScreen))
 287                 return FALSE;
 288
 289 /*
 290 #ifdef RANDR
 291         if (!sdlRandRInit (pScreen))
 292                 return FALSE;
 293 #endif
 294 */
 295         return TRUE;
 296 }
 297
 298 static void sdlKeyboardFini(KdKeyboardInfo *ki)
 299 {
 300         sdlKeyboard = NULL;
 301 }
 302
 303 static Bool sdlKeyboardInit(KdKeyboardInfo *ki)
 304 {
 305         ki->minScanCode = 8;
 306         ki->maxScanCode = 255;
 307         ki->keySyms.minKeyCode = 8;
 308         ki->keySyms.maxKeyCode = 255;
 309         ki->keySyms.mapWidth = 2;
 310         memcpy(ki->keySyms.map, sdlKeymap, sizeof(sdlKeymap));
 311
 312         sdlKeyboard = ki;
 313
 314         return TRUE;
 315 }
 316
 317 static Bool sdlMouseInit (KdPointerInfo *pi)
 318 {
 319         sdlPointer = pi;
 320         return TRUE;
 321 }
 322
 323 static void sdlMouseFini(KdPointerInfo *pi)
 324 {
 325         sdlPointer = NULL;
 326 }
 327
 328
 329 void InitCard(char *name)
 330 {
 331         KdCardAttr attr;
 332         KdCardInfoAdd (&sdlFuncs, &attr, 0);
 333 #ifdef DEBUG
 334         printf("InitCard: %s\n", name);
 335 #endif
 336 }
 337
 338 void InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
 339 {
 340         KdInitOutput(pScreenInfo, argc, argv);
 341 #ifdef DEBUG
 342         printf("InitOutput()\n");
 343 #endif
 344 }
 345
 346 void InitInput(int argc, char **argv)
 347 {
 348         KdPointerInfo *pi;
 349         KdKeyboardInfo *ki;
 350
 351         KdAddKeyboardDriver(&sdlKeyboardDriver);
 352         KdAddPointerDriver(&sdlMouseDriver);
 353
 354         ki = KdParseKeyboard("keyboard");
 355         KdAddKeyboard(ki);
 356         pi = KdParsePointer("mouse");
 357         KdAddPointer(pi);
 358
 359         KdInitInput();
 360 }
 361
 362 void ddxUseMsg(void)
 363 {
 364         KdUseMsg();
 365 }
 366
 367 int ddxProcessArgument(int argc, char **argv, int i)
 368 {
 369         return KdProcessArgument(argc, argv, i);
 370 }
 371
 372 void sdlTimer(void)
 373 {
 374         static int buttonState=0;
 375         SDL_Event event;
 376         SDL_ShowCursor(FALSE);
 377         /* get the mouse state */
 378         while ( SDL_PollEvent(&event) ) {
 379                 switch (event.type) {
 380                         case SDL_MOUSEMOTION:
 381                                 KdEnqueuePointerEvent(sdlPointer, mouseState, event.motion.x, event.motion.y, 0);
 382                                 break;
 383                         case SDL_MOUSEBUTTONDOWN:
 384                                 switch(event.button.button)
 385                                 {
 386                                         case 1:
 387                                                 buttonState=KD_BUTTON_1;
 388                                                 break;
 389                                         case 2:
 390                                                 buttonState=KD_BUTTON_2;
 391                                                 break;
 392                                         case 3:
 393                                                 buttonState=KD_BUTTON_3;
 394                                                 break;
 395                                 }
 396                                 mouseState|=buttonState;
 397                                 KdEnqueuePointerEvent(sdlPointer, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
 398                                 break;
 399                         case SDL_MOUSEBUTTONUP:
 400                                 switch(event.button.button)
 401                                 {
 402                                         case 1:
 403                                                 buttonState=KD_BUTTON_1;
 404                                                 break;
 405                                         case 2:
 406                                                 buttonState=KD_BUTTON_2;
 407                                                 break;
 408                                         case 3:
 409                                                 buttonState=KD_BUTTON_3;
 410                                                 break;
 411                                 }
 412                                 mouseState &= ~buttonState;
 413                                 KdEnqueuePointerEvent(sdlPointer, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
 414                                 break;
 415                         case SDL_KEYDOWN:
 416                         case SDL_KEYUP:
 417 #ifdef DEBUG
 418                                 printf("Keycode: %d\n", event.key.keysym.scancode);
 419 #endif
 420                                 KdEnqueueKeyboardEvent (sdlKeyboard, event.key.keysym.scancode, event.type==SDL_KEYUP);
 421                                 break;
 422
 423                         case SDL_QUIT:
 424                                 /* this should never happen */
 425                                 SDL_Quit();
 426                 }
 427         }
 428 }
 429
 430 static int xsdlInit(void)
 431 {
 432 #ifdef DEBUG
 433         printf("Calling SDL_Init()\n");
 434 #endif
 435         return SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
 436 }
 437
 438
 439 static void xsdlFini(void)
 440 {
 441         SDL_Quit();
 442 }
 443
 444 KdOsFuncs sdlOsFuncs={
 445         .Init = xsdlInit,
 446         .Fini = xsdlFini,
 447         .pollEvents = sdlTimer,
 448 };
 449
 450 void OsVendorInit (void)
 451 {
 452     KdOsInit (&sdlOsFuncs);
 453 }
 454
 455