Mercurial > sdl-ios-xcode
view src/video/SDL_blit.h @ 4393:9afe12fb4c41 SDL-1.2
Fixed bug #901
Tim Angus 2009-12-11 11:45:46 PST
Disable mouse event generation when state is not SDL_APPMOUSEFOCUS
If a Windows SDL application is minimised by using alt-tab, SDL_APPMOUSEFOCUS
is lost as part of the minimisation. Unfortunately, the directx driver doesn't
pay any attention to this state when generating mouse button events, so
clicking on the Desktop can cause mouse clicks in the SDL application, while
it's still minimised. The attached patch fixes this. It looks much more
complicated than it actually is due to indentation; here it is ignoring
whitespace:
tma@abraxas:~/sources/SDL-1.2-svn$ svn diff -x -b
Index: src/video/windx5/SDL_dx5events.c
===================================================================
--- src/video/windx5/SDL_dx5events.c (revision 5376)
+++ src/video/windx5/SDL_dx5events.c (working copy)
@@ -374,10 +374,9 @@
if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
mouse_lost = 1;
ClipCursor(NULL);
- }
-
+ } else {
/* If the mouse was lost, regain some sense of mouse state */
- if ( mouse_lost && (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
+ if ( mouse_lost ) {
POINT mouse_pos;
Uint8 old_state;
Uint8 new_state;
@@ -548,6 +547,7 @@
if ( xrel || yrel ) {
post_mouse_motion(1, xrel, yrel);
}
+ }
}
/* The main Win32 event handler */
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Mon, 14 Dec 2009 22:41:31 +0000 |
| parents | 2d00ed718720 |
| children |
line wrap: on
line source
/* SDL - Simple DirectMedia Layer Copyright (C) 1997-2009 Sam Lantinga This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Sam Lantinga slouken@libsdl.org */ #include "SDL_config.h" #ifndef _SDL_blit_h #define _SDL_blit_h #include "SDL_endian.h" /* The structure passed to the low level blit functions */ typedef struct { Uint8 *s_pixels; int s_width; int s_height; int s_skip; Uint8 *d_pixels; int d_width; int d_height; int d_skip; void *aux_data; SDL_PixelFormat *src; Uint8 *table; SDL_PixelFormat *dst; } SDL_BlitInfo; /* The type definition for the low level blit functions */ typedef void (*SDL_loblit)(SDL_BlitInfo *info); /* This is the private info structure for software accelerated blits */ struct private_swaccel { SDL_loblit blit; void *aux_data; }; /* Blit mapping definition */ typedef struct SDL_BlitMap { SDL_Surface *dst; int identity; Uint8 *table; SDL_blit hw_blit; SDL_blit sw_blit; struct private_hwaccel *hw_data; struct private_swaccel *sw_data; /* the version count matches the destination; mismatch indicates an invalid mapping */ unsigned int format_version; } SDL_BlitMap; /* Functions found in SDL_blit.c */ extern int SDL_CalculateBlit(SDL_Surface *surface); /* Functions found in SDL_blit_{0,1,N,A}.c */ extern SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int complex); extern SDL_loblit SDL_CalculateBlit1(SDL_Surface *surface, int complex); extern SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int complex); extern SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int complex); /* * Useful macros for blitting routines */ #define FORMAT_EQUAL(A, B) \ ((A)->BitsPerPixel == (B)->BitsPerPixel \ && ((A)->Rmask == (B)->Rmask) && ((A)->Amask == (B)->Amask)) /* Load pixel of the specified format from a buffer and get its R-G-B values */ /* FIXME: rescale values to 0..255 here? */ #define RGB_FROM_PIXEL(Pixel, fmt, r, g, b) \ { \ r = (((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss); \ g = (((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss); \ b = (((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss); \ } #define RGB_FROM_RGB565(Pixel, r, g, b) \ { \ r = (((Pixel&0xF800)>>11)<<3); \ g = (((Pixel&0x07E0)>>5)<<2); \ b = ((Pixel&0x001F)<<3); \ } #define RGB_FROM_RGB555(Pixel, r, g, b) \ { \ r = (((Pixel&0x7C00)>>10)<<3); \ g = (((Pixel&0x03E0)>>5)<<3); \ b = ((Pixel&0x001F)<<3); \ } #define RGB_FROM_RGB888(Pixel, r, g, b) \ { \ r = ((Pixel&0xFF0000)>>16); \ g = ((Pixel&0xFF00)>>8); \ b = (Pixel&0xFF); \ } #define RETRIEVE_RGB_PIXEL(buf, bpp, Pixel) \ do { \ switch (bpp) { \ case 2: \ Pixel = *((Uint16 *)(buf)); \ break; \ \ case 3: { \ Uint8 *B = (Uint8 *)(buf); \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \ } else { \ Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \ } \ } \ break; \ \ case 4: \ Pixel = *((Uint32 *)(buf)); \ break; \ \ default: \ Pixel = 0; /* appease gcc */ \ break; \ } \ } while(0) #define DISEMBLE_RGB(buf, bpp, fmt, Pixel, r, g, b) \ do { \ switch (bpp) { \ case 2: \ Pixel = *((Uint16 *)(buf)); \ break; \ \ case 3: { \ Uint8 *B = (Uint8 *)buf; \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \ } else { \ Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \ } \ } \ break; \ \ case 4: \ Pixel = *((Uint32 *)(buf)); \ break; \ \ default: \ Pixel = 0; /* prevent gcc from complaining */ \ break; \ } \ RGB_FROM_PIXEL(Pixel, fmt, r, g, b); \ } while(0) /* Assemble R-G-B values into a specified pixel format and store them */ #ifdef __NDS__ /* FIXME */ #define PIXEL_FROM_RGB(Pixel, fmt, r, g, b) \ { \ Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ ((g>>fmt->Gloss)<<fmt->Gshift)| \ ((b>>fmt->Bloss)<<fmt->Bshift) | (1<<15); \ } #else #define PIXEL_FROM_RGB(Pixel, fmt, r, g, b) \ { \ Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ ((g>>fmt->Gloss)<<fmt->Gshift)| \ ((b>>fmt->Bloss)<<fmt->Bshift); \ } #endif /* __NDS__ FIXME */ #define RGB565_FROM_RGB(Pixel, r, g, b) \ { \ Pixel = ((r>>3)<<11)|((g>>2)<<5)|(b>>3); \ } #define RGB555_FROM_RGB(Pixel, r, g, b) \ { \ Pixel = ((r>>3)<<10)|((g>>3)<<5)|(b>>3); \ } #define RGB888_FROM_RGB(Pixel, r, g, b) \ { \ Pixel = (r<<16)|(g<<8)|b; \ } #define ASSEMBLE_RGB(buf, bpp, fmt, r, g, b) \ { \ switch (bpp) { \ case 2: { \ Uint16 Pixel; \ \ PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ *((Uint16 *)(buf)) = Pixel; \ } \ break; \ \ case 3: { \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ *((buf)+fmt->Rshift/8) = r; \ *((buf)+fmt->Gshift/8) = g; \ *((buf)+fmt->Bshift/8) = b; \ } else { \ *((buf)+2-fmt->Rshift/8) = r; \ *((buf)+2-fmt->Gshift/8) = g; \ *((buf)+2-fmt->Bshift/8) = b; \ } \ } \ break; \ \ case 4: { \ Uint32 Pixel; \ \ PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ *((Uint32 *)(buf)) = Pixel; \ } \ break; \ } \ } #define ASSEMBLE_RGB_AMASK(buf, bpp, fmt, r, g, b, Amask) \ { \ switch (bpp) { \ case 2: { \ Uint16 *bufp; \ Uint16 Pixel; \ \ bufp = (Uint16 *)buf; \ PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ *bufp = Pixel | (*bufp & Amask); \ } \ break; \ \ case 3: { \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ *((buf)+fmt->Rshift/8) = r; \ *((buf)+fmt->Gshift/8) = g; \ *((buf)+fmt->Bshift/8) = b; \ } else { \ *((buf)+2-fmt->Rshift/8) = r; \ *((buf)+2-fmt->Gshift/8) = g; \ *((buf)+2-fmt->Bshift/8) = b; \ } \ } \ break; \ \ case 4: { \ Uint32 *bufp; \ Uint32 Pixel; \ \ bufp = (Uint32 *)buf; \ PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ *bufp = Pixel | (*bufp & Amask); \ } \ break; \ } \ } /* FIXME: Should we rescale alpha into 0..255 here? */ #define RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a) \ { \ r = ((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss; \ g = ((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss; \ b = ((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss; \ a = ((Pixel&fmt->Amask)>>fmt->Ashift)<<fmt->Aloss; \ } #define RGBA_FROM_8888(Pixel, fmt, r, g, b, a) \ { \ r = (Pixel&fmt->Rmask)>>fmt->Rshift; \ g = (Pixel&fmt->Gmask)>>fmt->Gshift; \ b = (Pixel&fmt->Bmask)>>fmt->Bshift; \ a = (Pixel&fmt->Amask)>>fmt->Ashift; \ } #define RGBA_FROM_RGBA8888(Pixel, r, g, b, a) \ { \ r = (Pixel>>24); \ g = ((Pixel>>16)&0xFF); \ b = ((Pixel>>8)&0xFF); \ a = (Pixel&0xFF); \ } #define RGBA_FROM_ARGB8888(Pixel, r, g, b, a) \ { \ r = ((Pixel>>16)&0xFF); \ g = ((Pixel>>8)&0xFF); \ b = (Pixel&0xFF); \ a = (Pixel>>24); \ } #define RGBA_FROM_ABGR8888(Pixel, r, g, b, a) \ { \ r = (Pixel&0xFF); \ g = ((Pixel>>8)&0xFF); \ b = ((Pixel>>16)&0xFF); \ a = (Pixel>>24); \ } #define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a) \ do { \ switch (bpp) { \ case 2: \ Pixel = *((Uint16 *)(buf)); \ break; \ \ case 3: {/* FIXME: broken code (no alpha) */ \ Uint8 *b = (Uint8 *)buf; \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ Pixel = b[0] + (b[1] << 8) + (b[2] << 16); \ } else { \ Pixel = (b[0] << 16) + (b[1] << 8) + b[2]; \ } \ } \ break; \ \ case 4: \ Pixel = *((Uint32 *)(buf)); \ break; \ \ default: \ Pixel = 0; /* stop gcc complaints */ \ break; \ } \ RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a); \ Pixel &= ~fmt->Amask; \ } while(0) /* FIXME: this isn't correct, especially for Alpha (maximum != 255) */ #ifdef __NDS__ /* FIXME */ #define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \ { \ Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ ((g>>fmt->Gloss)<<fmt->Gshift)| \ ((b>>fmt->Bloss)<<fmt->Bshift)| \ ((a>>fmt->Aloss)<<fmt->Ashift) | (1<<15); \ } #else #define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \ { \ Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ ((g>>fmt->Gloss)<<fmt->Gshift)| \ ((b>>fmt->Bloss)<<fmt->Bshift)| \ ((a>>fmt->Aloss)<<fmt->Ashift); \ } #endif /* __NDS__ FIXME */ #define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a) \ { \ switch (bpp) { \ case 2: { \ Uint16 Pixel; \ \ PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \ *((Uint16 *)(buf)) = Pixel; \ } \ break; \ \ case 3: { /* FIXME: broken code (no alpha) */ \ if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ *((buf)+fmt->Rshift/8) = r; \ *((buf)+fmt->Gshift/8) = g; \ *((buf)+fmt->Bshift/8) = b; \ } else { \ *((buf)+2-fmt->Rshift/8) = r; \ *((buf)+2-fmt->Gshift/8) = g; \ *((buf)+2-fmt->Bshift/8) = b; \ } \ } \ break; \ \ case 4: { \ Uint32 Pixel; \ \ PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \ *((Uint32 *)(buf)) = Pixel; \ } \ break; \ } \ } /* Blend the RGB values of two Pixels based on a source alpha value */ #define ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB) \ do { \ dR = (((sR-dR)*(A)+255)>>8)+dR; \ dG = (((sG-dG)*(A)+255)>>8)+dG; \ dB = (((sB-dB)*(A)+255)>>8)+dB; \ } while(0) /* This is a very useful loop for optimizing blitters */ #if defined(_MSC_VER) && (_MSC_VER == 1300) /* There's a bug in the Visual C++ 7 optimizer when compiling this code */ #else #define USE_DUFFS_LOOP #endif #ifdef USE_DUFFS_LOOP /* 8-times unrolled loop */ #define DUFFS_LOOP8(pixel_copy_increment, width) \ { int n = (width+7)/8; \ switch (width & 7) { \ case 0: do { pixel_copy_increment; \ case 7: pixel_copy_increment; \ case 6: pixel_copy_increment; \ case 5: pixel_copy_increment; \ case 4: pixel_copy_increment; \ case 3: pixel_copy_increment; \ case 2: pixel_copy_increment; \ case 1: pixel_copy_increment; \ } while ( --n > 0 ); \ } \ } /* 4-times unrolled loop */ #define DUFFS_LOOP4(pixel_copy_increment, width) \ { int n = (width+3)/4; \ switch (width & 3) { \ case 0: do { pixel_copy_increment; \ case 3: pixel_copy_increment; \ case 2: pixel_copy_increment; \ case 1: pixel_copy_increment; \ } while ( --n > 0 ); \ } \ } /* 2 - times unrolled loop */ #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ double_pixel_copy_increment, width) \ { int n, w = width; \ if( w & 1 ) { \ pixel_copy_increment; \ w--; \ } \ if ( w > 0 ) { \ n = ( w + 2) / 4; \ switch( w & 2 ) { \ case 0: do { double_pixel_copy_increment; \ case 2: double_pixel_copy_increment; \ } while ( --n > 0 ); \ } \ } \ } /* 2 - times unrolled loop 4 pixels */ #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ double_pixel_copy_increment, \ quatro_pixel_copy_increment, width) \ { int n, w = width; \ if(w & 1) { \ pixel_copy_increment; \ w--; \ } \ if(w & 2) { \ double_pixel_copy_increment; \ w -= 2; \ } \ if ( w > 0 ) { \ n = ( w + 7 ) / 8; \ switch( w & 4 ) { \ case 0: do { quatro_pixel_copy_increment; \ case 4: quatro_pixel_copy_increment; \ } while ( --n > 0 ); \ } \ } \ } /* Use the 8-times version of the loop by default */ #define DUFFS_LOOP(pixel_copy_increment, width) \ DUFFS_LOOP8(pixel_copy_increment, width) #else /* Don't use Duff's device to unroll loops */ #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ double_pixel_copy_increment, width) \ { int n = width; \ if( n & 1 ) { \ pixel_copy_increment; \ n--; \ } \ n=n>>1; \ for(; n > 0; --n) { \ double_pixel_copy_increment; \ } \ } /* Don't use Duff's device to unroll loops */ #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ double_pixel_copy_increment, \ quatro_pixel_copy_increment, width) \ { int n = width; \ if(n & 1) { \ pixel_copy_increment; \ n--; \ } \ if(n & 2) { \ double_pixel_copy_increment; \ n -= 2; \ } \ n=n>>2; \ for(; n > 0; --n) { \ quatro_pixel_copy_increment; \ } \ } /* Don't use Duff's device to unroll loops */ #define DUFFS_LOOP(pixel_copy_increment, width) \ { int n; \ for ( n=width; n > 0; --n ) { \ pixel_copy_increment; \ } \ } #define DUFFS_LOOP8(pixel_copy_increment, width) \ DUFFS_LOOP(pixel_copy_increment, width) #define DUFFS_LOOP4(pixel_copy_increment, width) \ DUFFS_LOOP(pixel_copy_increment, width) #endif /* USE_DUFFS_LOOP */ /* Prevent Visual C++ 6.0 from printing out stupid warnings */ #if defined(_MSC_VER) && (_MSC_VER >= 600) #pragma warning(disable: 4550) #endif #endif /* _SDL_blit_h */