test/testwm.c
changeset 0 74212992fb08
child 87 3ef4bc90c388
equal deleted inserted replaced
-1:000000000000 0:74212992fb08
       
     1 
       
     2 /* Test out the window manager interaction functions */
       
     3 
       
     4 #include <stdio.h>
       
     5 #include <stdlib.h>
       
     6 #include <string.h>
       
     7 
       
     8 #include "SDL.h"
       
     9 
       
    10 /* Is the cursor visible? */
       
    11 static int visible = 1;
       
    12 
       
    13 SDL_Surface *LoadIconSurface(char *file, Uint8 **maskp)
       
    14 {
       
    15 	SDL_Surface *icon;
       
    16 	Uint8       *pixels;
       
    17 	Uint8       *mask;
       
    18 	int          mlen, i;
       
    19 
       
    20 	*maskp = NULL;
       
    21 
       
    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 	}
       
    28 
       
    29 	/* Check width and height */
       
    30 	if ( (icon->w%8) != 0 ) {
       
    31 		fprintf(stderr, "Icon width must be a multiple of 8!\n");
       
    32 		SDL_FreeSurface(icon);
       
    33 		return(NULL);
       
    34 	}
       
    35 	if ( icon->format->palette == NULL ) {
       
    36 		fprintf(stderr, "Icon must have a palette!\n");
       
    37 		SDL_FreeSurface(icon);
       
    38 		return(NULL);
       
    39 	}
       
    40 
       
    41 	/* Set the colorkey */
       
    42 	SDL_SetColorKey(icon, SDL_SRCCOLORKEY, *((Uint8 *)icon->pixels));
       
    43 
       
    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");
       
    54 		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 }
       
    68 
       
    69 void HotKey_ToggleFullScreen(void)
       
    70 {
       
    71 	SDL_Surface *screen;
       
    72 
       
    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 }
       
    81 
       
    82 void HotKey_ToggleGrab(void)
       
    83 {
       
    84 	SDL_GrabMode mode;
       
    85 
       
    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 }
       
   100 
       
   101 void HotKey_Iconify(void)
       
   102 {
       
   103 	printf("Ctrl-Z: iconifying window!\n");
       
   104 	SDL_WM_IconifyWindow();
       
   105 }
       
   106 
       
   107 void HotKey_Quit(void)
       
   108 {
       
   109 	SDL_Event event;
       
   110 
       
   111 	printf("Posting internal quit request\n");
       
   112 	event.type = SDL_USEREVENT;
       
   113 	SDL_PushEvent(&event);
       
   114 }
       
   115 
       
   116 int FilterEvents(const SDL_Event *event)
       
   117 {
       
   118 	static int reallyquit = 0;
       
   119 
       
   120 	switch (event->type) {
       
   121 
       
   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");
       
   133 
       
   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);
       
   141 
       
   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;
       
   147 				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);
       
   154 
       
   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);
       
   162 
       
   163 		case SDL_KEYDOWN:
       
   164 			if ( event->key.keysym.sym == SDLK_ESCAPE ) {
       
   165 				HotKey_Quit();
       
   166 			}
       
   167 			if ( (event->key.keysym.sym == SDLK_g) &&
       
   168 			     (event->key.keysym.mod & KMOD_CTRL) ) {
       
   169 				HotKey_ToggleGrab();
       
   170 			}
       
   171 			if ( (event->key.keysym.sym == SDLK_z) &&
       
   172 			     (event->key.keysym.mod & KMOD_CTRL) ) {
       
   173 				HotKey_Iconify();
       
   174 			}
       
   175 			if ( (event->key.keysym.sym == SDLK_RETURN) &&
       
   176 			     (event->key.keysym.mod & KMOD_ALT) ) {
       
   177 				HotKey_ToggleFullScreen();
       
   178 			}
       
   179 			return(0);
       
   180 
       
   181 		/* Pass the video resize event through .. */
       
   182 		case SDL_VIDEORESIZE:
       
   183 			return(1);
       
   184 
       
   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);
       
   194 
       
   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);
       
   200 
       
   201 		/* Drop all other events */
       
   202 		default:
       
   203 			return(0);
       
   204 	}
       
   205 }
       
   206 
       
   207 static Uint8  video_bpp;
       
   208 static Uint32 video_flags;
       
   209 
       
   210 int SetVideoMode(int w, int h)
       
   211 {
       
   212 	SDL_Surface *screen;
       
   213 	int i;
       
   214 	Uint8 *buffer;
       
   215 	SDL_Color palette[256];
       
   216 
       
   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");
       
   225 
       
   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 	}
       
   232 	SDL_SetColors(screen, palette, 0, 256);
       
   233 	if ( SDL_LockSurface(screen) < 0 ) {
       
   234 		fprintf(stderr, "Couldn't lock display surface: %s\n",
       
   235 							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 	}
       
   244 	SDL_UnlockSurface(screen);
       
   245 	SDL_UpdateRect(screen, 0, 0, 0, 0);
       
   246 
       
   247 	return(0);
       
   248 }
       
   249 
       
   250 int main(int argc, char *argv[])
       
   251 {
       
   252 	SDL_Event event;
       
   253 	char *title;
       
   254 	SDL_Surface *icon;
       
   255 	Uint8 *icon_mask;
       
   256 	int parsed;
       
   257 
       
   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);
       
   264 
       
   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 	}
       
   293 
       
   294 	/* Set the icon -- this must be done before the first mode set */
       
   295 	icon = LoadIconSurface("icon.bmp", &icon_mask);
       
   296 	if ( icon != NULL ) {
       
   297 		SDL_WM_SetIcon(icon, icon_mask);
       
   298 	}
       
   299 	if ( icon_mask != NULL )
       
   300 		free(icon_mask);
       
   301 
       
   302 	/* Set the title bar */
       
   303 	if ( argv[1] == NULL )
       
   304 		title = "Testing  1.. 2.. 3...";
       
   305 	else
       
   306 		title = argv[1];
       
   307 	SDL_WM_SetCaption(title, "testwm");
       
   308 
       
   309 	/* See if it's really set */
       
   310 	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");
       
   315 
       
   316 	/* Initialize the display */
       
   317 	if ( SetVideoMode(640, 480) < 0 ) {
       
   318 		return(1);
       
   319 	}
       
   320 
       
   321 	/* Set an event filter that discards everything but QUIT */
       
   322 	SDL_SetEventFilter(FilterEvents);
       
   323 
       
   324 	/* Ignore key up events, they don't even get filtered */
       
   325 	SDL_EventState(SDL_KEYUP, SDL_IGNORE);
       
   326 
       
   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);
       
   333 				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 }