modes = ((SDL_Rect **)-1);		}	}	return(modes);}/* Various screen update functions available */static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);/* Find the closest display mode for fullscreen */static bool BE_FindClosestFSMode(_THIS, int width, int height, int bpp,					 display_mode *mode){	BScreen bscreen;	uint32 i, nmodes;	SDL_Rect **modes;	display_mode *dmodes;	modes = SDL_modelist[((bpp+7)/8)-1];	for ( i=0; modes[i] && (modes[i]->w > width) &&		      (modes[i]->h > height); ++i ) {		/* still looking */	}	if ( ! modes[i] || (modes[i]->w < width) || (modes[i]->h < width) ) {		--i;	/* We went too far */	}	width = modes[i]->w;	height = modes[i]->h;      	bscreen.GetModeList(&dmodes, &nmodes);	for ( i = 0; i < nmodes; ++i ) {		if ( (bpp == ColorSpaceToBitsPerPixel(dmodes[i].space)) &&		     (width == dmodes[i].virtual_width) &&		     (height == dmodes[i].virtual_height) ) {			break;		}	}	if ( i != nmodes ) {		*mode = dmodes[i];		return true;	} else {		return false;	}	}static int BE_SetFullScreen(_THIS, SDL_Surface *screen, int fullscreen){	int was_fullscreen;	bool needs_unlock;	BScreen bscreen;	BRect bounds;	display_mode mode;	int width, height, bpp;	/* Set the fullscreen mode */	was_fullscreen = SDL_Win->IsFullScreen();	SDL_Win->SetFullScreen(fullscreen);	fullscreen = SDL_Win->IsFullScreen();	width = screen->w;	height = screen->h;	/* Set the appropriate video mode */	if ( fullscreen ) {		bpp = screen->format->BitsPerPixel;		bscreen.GetMode(&mode);		if ( (bpp != ColorSpaceToBitsPerPixel(mode.space)) ||		     (width != mode.virtual_width) ||		     (height != mode.virtual_height)) {			if(BE_FindClosestFSMode(_this, width, height, bpp, &mode)) {				bscreen.SetMode(&mode);				/* This simply stops the next resize event from being				 * sent to the SDL handler.				 */				SDL_Win->InhibitResize();			} else {				fullscreen = 0;				SDL_Win->SetFullScreen(fullscreen);			}		}	}	if ( was_fullscreen && ! fullscreen ) {		bscreen.SetMode(&saved_mode);	}	if ( SDL_Win->Lock() ) {		int xoff, yoff;		if ( SDL_Win->Shown() ) {			needs_unlock = 1;			SDL_Win->Hide();		} else {			needs_unlock = 0;		}		/* This resizes the window and view area, but inhibits resizing		 * of the BBitmap due to the InhibitResize call above. Thus the		 * bitmap (pixel data) never changes.		 */		SDL_Win->ResizeTo(width, height);		bounds = bscreen.Frame();		/* Calculate offsets - used either to center window		 * (windowed mode) or to set drawing offsets (fullscreen mode)		 */		xoff = (bounds.IntegerWidth() - width)/2;		yoff = (bounds.IntegerHeight() - height)/2;		if ( fullscreen ) {			/* Set offset for drawing */			SDL_Win->SetXYOffset(xoff, yoff);		} else {			/* Center window and reset the drawing offset */			SDL_Win->SetXYOffset(0, 0);		}		if ( ! needs_unlock || was_fullscreen ) {			/* Center the window the first time */			SDL_Win->MoveTo(xoff > 0 ? (float)xoff : 0.0f,					yoff > 0 ? (float)yoff : 0.0f);		}		SDL_Win->Show();				/* Unlock the window manually after the first Show() */		if ( needs_unlock ) {			SDL_Win->Unlock();		}	}	/* Set the fullscreen flag in the screen surface */	if ( fullscreen ) {		screen->flags |= SDL_FULLSCREEN;	} else {		screen->flags &= ~SDL_FULLSCREEN; 	}	return(1);}static int BE_ToggleFullScreen(_THIS, int fullscreen){	return BE_SetFullScreen(_this, _this->screen, fullscreen);}/* FIXME: check return values and cleanup here */SDL_Surface *BE_SetVideoMode(_THIS, SDL_Surface *current,				int width, int height, int bpp, Uint32 flags){	BScreen bscreen;	BBitmap *bbitmap;	BRect bounds;	/* Create the view for this window */	if ( SDL_Win->CreateView(flags) < 0 ) {		return(NULL);	}	current->flags = 0;		/* Clear flags */	current->w = width;	current->h = height;	SDL_Win->SetType(B_TITLED_WINDOW);	if ( flags & SDL_NOFRAME ) {		current->flags |= SDL_NOFRAME;		SDL_Win->SetLook(B_NO_BORDER_WINDOW_LOOK);	} else {		if ( (flags & SDL_RESIZABLE) && !(flags & SDL_OPENGL) )  {			current->flags |= SDL_RESIZABLE;			/* We don't want opaque resizing (TM). :-) */			SDL_Win->SetFlags(B_OUTLINE_RESIZE);		} else {			SDL_Win->SetFlags(B_NOT_RESIZABLE|B_NOT_ZOOMABLE);		}	}	if ( flags & SDL_OPENGL ) {		current->flags |= SDL_OPENGL;		current->pitch = 0;		current->pixels = NULL;		_this->UpdateRects = NULL;			} else {		/* Create the BBitmap framebuffer */		bounds.top = 0; bounds.left = 0;		bounds.right = width-1;		bounds.bottom = height-1;		bbitmap = new BBitmap(bounds, bscreen.ColorSpace());		if ( ! bbitmap->IsValid() ) {			SDL_SetError("Couldn't create screen bitmap");			delete bbitmap;			return(NULL);		}		current->pitch = bbitmap->BytesPerRow();		current->pixels = (void *)bbitmap->Bits();		SDL_Win->SetBitmap(bbitmap);		_this->UpdateRects = BE_NormalUpdate;	}	/* Set the correct fullscreen mode */	BE_SetFullScreen(_this, current, flags & SDL_FULLSCREEN ? 1 : 0);	/* We're done */	return(current);}/* Update the current mouse state and position */void BE_UpdateMouse(_THIS){	BPoint point;	uint32 buttons;	if ( SDL_Win->Lock() ) {		/* Get new input state, if still active */		if ( SDL_Win->IsActive() ) {			(SDL_Win->View())->GetMouse(&point, &buttons, true);		} else {			point.x = -1;			point.y = -1;		}		SDL_Win->Unlock();		if ( (point.x >= 0) && (point.x < SDL_VideoSurface->w) &&		     (point.y >= 0) && (point.y < SDL_VideoSurface->h) ) {			SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);			SDL_PrivateMouseMotion(0, 0,					(Sint16)point.x, (Sint16)point.y);		} else {			SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);		}	}}/* We don't actually allow hardware surfaces other than the main one */static int BE_AllocHWSurface(_THIS, SDL_Surface *surface){	return(-1);}static void BE_FreeHWSurface(_THIS, SDL_Surface *surface){	return;}static int BE_LockHWSurface(_THIS, SDL_Surface *surface){	return(0);}static void BE_UnlockHWSurface(_THIS, SDL_Surface *surface){	return;}static void BE_NormalUpdate(_THIS, int numrects, SDL_Rect *rects){	if ( SDL_Win->BeginDraw() ) {		int i;		for ( i=0; i<numrects; ++i ) {			BRect rect;			rect.top = rects[i].y;			rect.left = rects[i].x;			rect.bottom = rect.top+rects[i].h-1;			rect.right = rect.left+rects[i].w-1;			SDL_Win->DrawAsync(rect);		}		SDL_Win->EndDraw();	}}#ifdef HAVE_OPENGLvoid BE_GL_SwapBuffers(_THIS){	SDL_Win->SwapBuffers();}#endif/* Is the system palette settable? */int BE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors){	int i;	SDL_Palette *palette;	const color_map *cmap = BScreen().ColorMap();	/* Get the screen colormap */	palette = _this->screen->format->palette;	for ( i=0; i<256; ++i ) {		palette->colors[i].r = cmap->color_list[i].red;		palette->colors[i].g = cmap->color_list[i].green;		palette->colors[i].b = cmap->color_list[i].blue;	}	return(0);}void BE_VideoQuit(_THIS){	int i, j;	if ( SDL_BlankCursor != NULL ) {		BE_FreeWMCursor(_this, SDL_BlankCursor);		SDL_BlankCursor = NULL;	}	for ( i=0; i<NUM_MODELISTS; ++i ) {		if ( SDL_modelist[i] ) {			for ( j=0; SDL_modelist[i][j]; ++j ) {				free(SDL_modelist[i][j]);			}			free(SDL_modelist[i]);			SDL_modelist[i] = NULL;		}	}	/* Restore the original video mode */	if ( _this->screen ) {		if ( (_this->screen->flags&SDL_FULLSCREEN) == SDL_FULLSCREEN ) {			BScreen bscreen;			bscreen.SetMode(&saved_mode);		}		_this->screen->pixels = NULL;	}	SDL_QuitBeApp();}}; /* Extern C */