FUNCTIONS

1. LoadIconSurface
2. HotKey_ToggleFullScreen
3. HotKey_ToggleGrab
4. HotKey_Iconify
5. HotKey_Quit
6. FilterEvents
7. SetVideoMode
8. main

   2 /* Test out the window manager interaction functions */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   8 #include "SDL.h"
  10 /* Is the cursor visible? */
  11 static int visible = 1;
  13 SDL_Surface *LoadIconSurface(char *file, Uint8 **maskp)
     /* [<][>][^][v][top][bottom][index][help] */
  14 {
  15         SDL_Surface *icon;
  16         Uint8       *pixels;
  17         Uint8       *mask;
  18         int          mlen, i;
  20         *maskp = NULL;
  22         /* Load the icon surface */
  23         icon = SDL_LoadBMP(file);
  24         if ( icon == NULL ) {
  25                 fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError());
  26                 return(NULL);
  27         }
  29         /* Check width and height */
  30         if ( (icon->w%8) != 0 ) {
  31                 fprintf(stderr, "Icon width must be a multiple of 8!\n");
SDL_FreeSurface(icon);
  33                 return(NULL);
  34         }
  35         if ( icon->format->palette == NULL ) {
  36                 fprintf(stderr, "Icon must have a palette!\n");
SDL_FreeSurface(icon);
  38                 return(NULL);
  39         }
  41         /* Set the colorkey */
SDL_SetColorKey(icon, SDL_SRCCOLORKEY, *((Uint8 *)icon->pixels));
  44         /* Create the mask */
  45         pixels = (Uint8 *)icon->pixels;
  46         printf("Transparent pixel: (%d,%d,%d)\n",
  47                                 icon->format->palette->colors[*pixels].r,
  48                                 icon->format->palette->colors[*pixels].g,
  49                                 icon->format->palette->colors[*pixels].b);
  50         mlen = icon->w*icon->h;
  51         mask = (Uint8 *)malloc(mlen/8);
  52         if ( mask == NULL ) {
  53                 fprintf(stderr, "Out of memory!\n");
SDL_FreeSurface(icon);
  55                 return(NULL);
  56         }
  57         memset(mask, 0, mlen/8);
  58         for ( i=0; i<mlen; ) {
  59                 if ( pixels[i] != *pixels )
  60                         mask[i/8] |= 0x01;
  61                 ++i;
  62                 if ( (i%8) != 0 )
  63                         mask[i/8] <<= 1;
  64         }
  65         *maskp = mask;
  66         return(icon);
  67 }
  69 void HotKey_ToggleFullScreen(void)
     /* [<][>][^][v][top][bottom][index][help] */
  70 {
  71         SDL_Surface *screen;
  73         screen = SDL_GetVideoSurface();
  74         if ( SDL_WM_ToggleFullScreen(screen) ) {
  75                 printf("Toggled fullscreen mode - now %s\n",
  76                     (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed");
  77         } else {
  78                 printf("Unable to toggle fullscreen mode\n");
  79         }
  80 }
  82 void HotKey_ToggleGrab(void)
     /* [<][>][^][v][top][bottom][index][help] */
  83 {
  84         SDL_GrabMode mode;
  86         printf("Ctrl-G: toggling input grab!\n");
  87         mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
  88         if ( mode == SDL_GRAB_ON ) {
  89                 printf("Grab was on\n");
  90         } else {
  91                 printf("Grab was off\n");
  92         }
  93         mode = SDL_WM_GrabInput(!mode);
  94         if ( mode == SDL_GRAB_ON ) {
  95                 printf("Grab is now on\n");
  96         } else {
  97                 printf("Grab is now off\n");
  98         }
  99 }
 101 void HotKey_Iconify(void)
     /* [<][>][^][v][top][bottom][index][help] */
 102 {
 103         printf("Ctrl-Z: iconifying window!\n");
SDL_WM_IconifyWindow();
 105 }
 107 void HotKey_Quit(void)
     /* [<][>][^][v][top][bottom][index][help] */
 108 {
 109         SDL_Event event;
 111         printf("Posting internal quit request\n");
 112         event.type = SDL_USEREVENT;
SDL_PushEvent(&event);
 114 }
 116 int FilterEvents(const SDL_Event *event)
     /* [<][>][^][v][top][bottom][index][help] */
 117 {
 118         static int reallyquit = 0;
 120         switch (event->type) {
 122                 case SDL_ACTIVEEVENT:
 123                         /* See what happened */
 124                         printf("App %s ",
 125                                 event->active.gain ? "gained" : "lost");
 126                         if ( event->active.state & SDL_APPACTIVE )
 127                                 printf("active ");
 128                         if ( event->active.state & SDL_APPMOUSEFOCUS )
 129                                 printf("mouse ");
 130                         if ( event->active.state & SDL_APPINPUTFOCUS )
 131                                 printf("input ");
 132                         printf("focus\n");
 134                         /* See if we are iconified or restored */
 135                         if ( event->active.state & SDL_APPACTIVE ) {
 136                                 printf("App has been %s\n",
 137                                         event->active.gain ?
 138                                                  "restored" : "iconified");
 139                         }
 140                         return(0);
 142                 /* We want to toggle visibility on buttonpress */
 143                 case SDL_MOUSEBUTTONDOWN:
 144                 case SDL_MOUSEBUTTONUP:
 145                         if ( event->button.state == SDL_PRESSED ) {
 146                                 visible = !visible;
SDL_ShowCursor(visible);
 148                         }
 149                         printf("Mouse button %d has been %s\n",
 150                                 event->button.button,
 151                                 (event->button.state == SDL_PRESSED) ?
 152                                                 "pressed" : "released");
 153                         return(0);
 155                 /* Show relative mouse motion */
 156                 case SDL_MOUSEMOTION:
 157 #if 0
 158                         printf("Mouse relative motion: {%d,%d}\n",
 159                                 event->motion.xrel, event->motion.yrel);
 160 #endif
 161                         return(0);
 163                 case SDL_KEYDOWN:
 164                         if ( event->key.keysym.sym == SDLK_ESCAPE ) {
HotKey_Quit();
 166                         }
 167                         if ( (event->key.keysym.sym == SDLK_g) &&
 168                              (event->key.keysym.mod & KMOD_CTRL) ) {
HotKey_ToggleGrab();
 170                         }
 171                         if ( (event->key.keysym.sym == SDLK_z) &&
 172                              (event->key.keysym.mod & KMOD_CTRL) ) {
HotKey_Iconify();
 174                         }
 175                         if ( (event->key.keysym.sym == SDLK_RETURN) &&
 176                              (event->key.keysym.mod & KMOD_ALT) ) {
HotKey_ToggleFullScreen();
 178                         }
 179                         return(0);
 181                 /* Pass the video resize event through .. */
 182                 case SDL_VIDEORESIZE:
 183                         return(1);
 185                 /* This is important!  Queue it if we want to quit. */
 186                 case SDL_QUIT:
 187                         if ( ! reallyquit ) {
 188                                 reallyquit = 1;
 189                                 printf("Quit requested\n");
 190                                 return(0);
 191                         }
 192                         printf("Quit demanded\n");
 193                         return(1);
 195                 /* This will never happen because events queued directly
 196                    to the event queue are not filtered.
 197                  */
 198                 case SDL_USEREVENT:
 199                         return(1);
 201                 /* Drop all other events */
 202                 default:
 203                         return(0);
 204         }
 205 }
 207 static Uint8  video_bpp;
 208 static Uint32 video_flags;
 210 int SetVideoMode(int w, int h)
     /* [<][>][^][v][top][bottom][index][help] */
 211 {
 212         SDL_Surface *screen;
 213         int i;
 214         Uint8 *buffer;
 215         SDL_Color palette[256];
 217         screen = SDL_SetVideoMode(w, h, video_bpp, video_flags);
 218         if (  screen == NULL ) {
 219                 fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
 220                                         w, h, video_bpp, SDL_GetError());
 221                 return(-1);
 222         }
 223         printf("Running in %s mode\n", screen->flags & SDL_FULLSCREEN ?
 224                                                 "fullscreen" : "windowed");
 226         /* Set the surface pixels and refresh! */
 227         for ( i=0; i<256; ++i ) {
 228                 palette[i].r = 255-i;
 229                 palette[i].g = 255-i;
 230                 palette[i].b = 255-i;
 231         }
SDL_SetColors(screen, palette, 0, 256);
 233         if ( SDL_LockSurface(screen) < 0 ) {
 234                 fprintf(stderr, "Couldn't lock display surface: %s\n",
SDL_GetError());
 236                 return(-1);
 237         }
 238         buffer = (Uint8 *)screen->pixels;
 239         for ( i=0; i<screen->h; ++i ) {
 240                 memset(buffer,(i*255)/screen->h,
 241                                 screen->w*screen->format->BytesPerPixel);
 242                 buffer += screen->pitch;
 243         }
SDL_UnlockSurface(screen);
SDL_UpdateRect(screen, 0, 0, 0, 0);
 247         return(0);
 248 }
 250 int main(int argc, char *argv[])
     /* [<][>][^][v][top][bottom][index][help] */
 251 {
 252         SDL_Event event;
 253         char *title;
 254         SDL_Surface *icon;
 255         Uint8 *icon_mask;
 256         int parsed;
 258         if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
 259                 fprintf(stderr,
 260                         "Couldn't initialize SDL: %s\n", SDL_GetError());
 261                 exit(1);
 262         }
 263         atexit(SDL_Quit);
 265         /* Check command line arguments */
 266         video_bpp = 8;
 267         video_flags = SDL_SWSURFACE;
 268         parsed = 1;
 269         while ( parsed ) {
 270                 if ( (argc >= 2) && (strcmp(argv[1], "-fullscreen") == 0) ) {
 271                         video_flags |= SDL_FULLSCREEN;
 272                         argc -= 1;
 273                         argv += 1;
 274                 } else
 275                 if ( (argc >= 2) && (strcmp(argv[1], "-resize") == 0) ) {
 276                         video_flags |= SDL_RESIZABLE;
 277                         argc -= 1;
 278                         argv += 1;
 279                 } else
 280                 if ( (argc >= 2) && (strcmp(argv[1], "-noframe") == 0) ) {
 281                         video_flags |= SDL_NOFRAME;
 282                         argc -= 1;
 283                         argv += 1;
 284                 } else
 285                 if ( (argc >= 3) && (strcmp(argv[1], "-bpp") == 0) ) {
 286                         video_bpp = atoi(argv[2]);
 287                         argc -= 2;
 288                         argv += 2;
 289                 } else {
 290                         parsed = 0;
 291                 }
 292         }
 294         /* Set the icon -- this must be done before the first mode set */
 295         icon = LoadIconSurface("icon.bmp", &icon_mask);
 296         if ( icon != NULL ) {
SDL_WM_SetIcon(icon, icon_mask);
 298         }
 299         if ( icon_mask != NULL )
 300                 free(icon_mask);
 302         /* Set the title bar */
 303         if ( argv[1] == NULL )
 304                 title = "Testing  1.. 2.. 3...";
 305         else
 306                 title = argv[1];
SDL_WM_SetCaption(title, "testwm");
 309         /* See if it's really set */
SDL_WM_GetCaption(&title, NULL);
 311         if ( title )
 312                 printf("Title was set to: %s\n", title);
 313         else
 314                 printf("No window title was set!\n");
 316         /* Initialize the display */
 317         if ( SetVideoMode(640, 480) < 0 ) {
 318                 return(1);
 319         }
 321         /* Set an event filter that discards everything but QUIT */
SDL_SetEventFilter(FilterEvents);
 324         /* Ignore key up events, they don't even get filtered */
SDL_EventState(SDL_KEYUP, SDL_IGNORE);
 327         /* Loop, waiting for QUIT */
 328         while ( SDL_WaitEvent(&event) ) {
 329                 switch (event.type) {
 330                         case SDL_VIDEORESIZE:
 331                                 printf("Got a resize event: %dx%d\n",
 332                                        event.resize.w, event.resize.h);
SetVideoMode(event.resize.w, event.resize.h);
 334                                 break;
 335                         case SDL_USEREVENT:
 336                                 printf("Handling internal quit request\n");
 337                                 /* Fall through to the quit handler */
 338                         case SDL_QUIT:
 339                                 printf("Bye bye..\n");
 340                                 return(0);
 341                         default:
 342                                 /* This should never happen */
 343                                 printf("Warning: Event %d wasn't filtered\n",
 344                                                                 event.type);
 345                                 break;
 346                 }
 347         }
 348         printf("SDL_WaitEvent() error: %s\n", SDL_GetError());
 349         return(255);
 350 }