wt: Wt::SDLDisplay Class Reference

Enumerator:

defaultWidth
defaultHeight
defaultDepth

Definition at line 35 of file sdldisplay.h.

00035                  {
00036         defaultWidth = 640,
00037         defaultHeight = 480,
00038         defaultDepth = 32,
00039     } DefaultSurface;

enum Wt::SDLSurface::Endian [inherited]

Enumerator:

IgnoreEndian
BigEndian
LittleEndian

Definition at line 44 of file sdlsurface.h.

00044                  {
00045         IgnoreEndian,
00046         BigEndian = SDL_BIG_ENDIAN,
00047         LittleEndian = SDL_LIL_ENDIAN
00048     } Endian;

enum Wt::SDLSurface::ScaleMode [inherited]

Enumerator:

ScaleFree
ScaleMin
ScaleMax

Definition at line 50 of file sdlsurface.h.

00050                  {
00051         ScaleFree,
00052         ScaleMin,
00053         ScaleMax
00054     } ScaleMode;

Wt::SDLDisplay::SDLDisplay	(	int	w = `defaultWidth`,
		int	h = `defaultHeight`,
		int	depth = `defaultDepth`,
		int	flags = `0`
	)

Initialize the target screen surface.

Definition at line 35 of file sdldisplay.cpp.

Referenced by load().

00036         : SDLSurface(SDL_SetVideoMode(w, h, depth,
00037                                       flagMap.state(
00038                                           flags ? flags
00039                                           : static_cast<int>(W::DefaultDisplayPixmapFlags)))),
00040 Singleton<SDLDisplay>(this) {}

Wt::SDLDisplay::SDLDisplay ( SDLSurface & src ) [protected]

copy constructor takes ownership. It is called from load()

Definition at line 42 of file sdldisplay.cpp.

00043 : SDLSurface(src),
00044 Singleton<SDLDisplay>(this) {}

Wt::SDLDisplay::SDLDisplay ( const SDLDisplay & ) [private]

int Wt::SDLSurface::alpha ( ) const [inline, inherited]

Definition at line 224 of file sdlsurface.h.

References Wt::SDLPixelFormat::alpha(), and Wt::SDLSurface::pixelFormat().

Referenced by Wt::SDLSurface::blitAlphaCopy(), Wt::SDLSurface::isTransparent(), and Wt::SDLSurface::setAlpha().

00224                       {
00225         return pixelFormat().alpha();
00226     }

Here is the call graph for this function:

void* Wt::SDLSurface::bits ( ) [inline, inherited]

Definition at line 162 of file sdlsurface.h.

References Wt::SDLSurface::pixels().

00162                  {
00163         return pixels();
00164     }

Here is the call graph for this function:

int Wt::SDLSurface::blit	(	int	x,
		int	y,
		const SDLSurface &	src,
		const SDLRect &	src_rect
	)			`[inherited]`

blit to from

SDL breakage

Definition at line 300 of file sdlsurface.cpp.

References Wt::deconst(), Wt::SDLSurface::detach(), and Wt::safe_blit().

00301                                                                      {
00302     ///SDL breakage
00303     SDLRect s = src_rect;
00304     SDLRect dst(x, y, 0, 0);
00305     detach();
00306     return safe_blit(deconst(src), s, *this, dst);
00307 }

Here is the call graph for this function:

int Wt::SDLSurface::blit	(	int	x,
		int	y,
		const SDLSurface &	src
	)			`[inherited]`

blit to

Definition at line 294 of file sdlsurface.cpp.

References Wt::deconst(), Wt::SDLSurface::detach(), and Wt::safe_blit().

00294                                                         {
00295     SDLRect dst(x, y, 0, 0);
00296     detach();
00297     return safe_blit(deconst(src), 0, *this, dst);
00298 }

Here is the call graph for this function:

int Wt::SDLSurface::blit ( const SDLSurface & src ) [inherited]

full blit

if (source surface has SDL_SRCALPHA set) { if (source surface has alpha channel (that is, format->Amask != 0)) blit using per-pixel alpha, ignoring any colour key else { if (source surface has SDL_SRCCOLORKEY set) blit using the colour key AND the per-surface alpha value else blit using the per-surface alpha value } } else { if (source surface has SDL_SRCCOLORKEY set) blit using the colour key else ordinary opaque rectangular blit }

Note: The per-surface alpha value of 128 is considered a special case and is optimised, so it's much faster than other per-surface values.

Alpha effects surface blitting in the following ways:

RGBA->RGB with SDL_SRCALPHA The source is alpha-blended with the destination, using the alpha channel. SDL_SRCCOLORKEY and the per-surface alpha are ignored.

RGBA->RGB without SDL_SRCALPHA The RGB data is copied from the source. The source alpha channel and the per-surface alpha value are ignored.

RGB->RGBA with SDL_SRCALPHA The source is alpha-blended with the destination using the per-surface alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied. The alpha channel of the copied pixels is set to opaque.

RGB->RGBA without SDL_SRCALPHA The RGB data is copied from the source and the alpha value of the copied pixels is set to opaque. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.

RGBA->RGBA with SDL_SRCALPHA The source is alpha-blended with the destination using the source alpha channel. The alpha channel in the destination surface is left untouched. SDL_SRCCOLORKEY is ignored.

RGBA->RGBA without SDL_SRCALPHA The RGBA data is copied to the destination surface. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.

RGB->RGB with SDL_SRCALPHA The source is alpha-blended with the destination using the per-surface alpha value. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.

RGB->RGB without SDL_SRCALPHA The RGB data is copied from the source. If SDL_SRCCOLORKEY is set, only the pixels not matching the colorkey value are copied.

Note: Note that RGBA->RGBA blits (with SDL_SRCALPHA set) keep the alpha of the destination surface. This means that you cannot compose two arbitrary RGBA surfaces this way and get the result you would expect from "overlaying" them; the destination alpha will work as a mask.

Also note that per-pixel and per-surface alpha cannot be combined; the per-pixel alpha is always used if available

Definition at line 289 of file sdlsurface.cpp.

References Wt::deconst(), Wt::SDLSurface::detach(), and Wt::safe_blit().

Referenced by Wt::SDLSurface::blitAlphaCopy(), and Wt::SDLSurface::convertDepth().

00289                                           {
00290     detach();
00291     return safe_blit(deconst(src), 0, *this, 0);
00292 }

Here is the call graph for this function:

int Wt::SDLSurface::blitAlphaCopy	(	int	x,
		int	y,
		const SDLSurface &	src,
		const SDLRect &	src_rect
	)			`[inherited]`

copy to from src rect

Definition at line 377 of file sdlsurface.cpp.

References Wt::SDLSurface::alpha(), Wt::SDLSurface::blit(), Wt::deconst(), Wt::SDLSurface::depth(), Wt::SDLSurface::hasAlpha(), Wt::SDLSurface::hasTransparentColor(), Wt::SDLColor::Opaque, Wt::SDLSurface::pixelFormat(), and Wt::SDLPixelFormat::transparentPixelValue().

00378                                                        {
00379     assert(depth() == src.depth());
00380 
00381     bool has_alpha = src.hasAlpha();
00382     bool has_colorkey = src.hasTransparentColor();
00383     int alpha = 0, pv = 0;
00384 
00385     // note: we can't use set/clearAlpha beacuse of detach
00386     if (has_alpha) {
00387         alpha = src.alpha();
00388         SDL_SetAlpha(deconst(src), 0, SDLColor::Opaque);
00389     }
00390 
00391     if (has_colorkey) {
00392         pv = src.pixelFormat().transparentPixelValue();
00393         SDL_SetColorKey(deconst(src), 0, 0);
00394     }
00395 
00396     int status = blit(x, y, src, src_rect);
00397 
00398     if (has_alpha) {
00399         SDL_SetAlpha(deconst(src), SDL_SRCALPHA, alpha);
00400     }
00401 
00402     if (has_colorkey) {
00403         SDL_SetColorKey(deconst(src), SDL_SRCCOLORKEY | SDL_RLEACCEL, pv);
00404     }
00405     return status;
00406 }

Here is the call graph for this function:

int Wt::SDLSurface::blitAlphaCopy	(	int	x,
		int	y,
		const SDLSurface &	src
	)			`[inherited]`

copy to from src

Definition at line 412 of file sdlsurface.cpp.

References Wt::SDLSurface::blitAlphaCopy(), Wt::SDLSurface::height(), and Wt::SDLSurface::width().

00412                                                                  {
00413     return blitAlphaCopy(x, y, src, SDLRect(0, 0, src.width(), src.height()));
00414 }

Here is the call graph for this function:

int Wt::SDLSurface::blitAlphaCopy ( const SDLSurface & src ) [inherited]

copy to from src

Definition at line 408 of file sdlsurface.cpp.

References Wt::SDLSurface::height(), and Wt::SDLSurface::width().

Referenced by Wt::SDLSurface::blitAlphaCopy().

00408                                                    {
00409     return blitAlphaCopy(0, 0, src, SDLRect(0, 0, src.width(), src.height()));
00410 }

Here is the call graph for this function:

int Wt::SDLSurface::bytesPerLine ( ) const [inline, inherited]

Definition at line 146 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::numBytes(), Wt::SDLSurface::pixelOffset(), and Wt::SDLSurface::scanLine().

00146                              {
00147         return sdl_surface->pitch;
00148     }

void Wt::SDLSurface::clearAlpha ( ) [inherited]

Definition at line 192 of file sdlsurface.cpp.

References Wt::SDLSurface::detach(), and Wt::SDLColor::Opaque.

00192                             {
00193     detach();
00194     SDL_SetAlpha(*this, 0, SDLColor::Opaque);
00195 }

Here is the call graph for this function:

void Wt::SDLSurface::clearTransparentColor ( ) [inherited]

Definition at line 182 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00182                                        {
00183     detach();
00184     SDL_SetColorKey(*this, 0, 0);
00185 }

Here is the call graph for this function:

SDLRect Wt::SDLSurface::clipRect ( ) const [inherited]

Definition at line 112 of file sdlsurface.cpp.

References Wt::deconst(), and Wt::SDLSurface::sdl_surface.

00112                                    {
00113     SDLRect r;
00114     SDL_GetClipRect(deconst(*this), r);
00115     assert(r == sdl_surface->clip_rect);
00116     return r;
00117 }

Here is the call graph for this function:

SDLColor Wt::SDLSurface::color ( int index ) const [inline, inherited]

Definition at line 205 of file sdlsurface.h.

References Wt::SDLPixelFormat::palette(), and Wt::SDLSurface::pixelFormat().

Referenced by Wt::SDLSurface::setPixelColor(), and Wt::SDLSurface::setTransparentColor().

00205                                     {
00206         return pixelFormat().palette()[index];
00207     }

Here is the call graph for this function:

int Wt::SDLSurface::convertDepth ( int new_depth ) [inherited]

Definition at line 354 of file sdlsurface.cpp.

References Wt::SDLSurface::blit(), Wt::SDLSurface::height(), Wt::SDLSurface::sdl_surface, Wt::SDLSurface::SDLSurface(), and Wt::SDLSurface::width().

00354                                           {
00355     SDLSurface dst = SDLSurface(width(), height(), new_depth);
00356     if (dst) {
00357         dst.blit(*this);
00358         sdl_surface = dst;
00359         return 0;
00360     }
00361     return -1;
00362 }

Here is the call graph for this function:

int Wt::SDLSurface::convertTo ( const SDLSurface src ) [inherited]

Definition at line 329 of file sdlsurface.cpp.

References Wt::SDLSurface::flags(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::sdl_surface.

00329                                               {
00330     if (*this == src)
00331         return 0;
00332     /// \bug GCC bug. does not enfoce constness
00333     SDLPixelFormat f = src.pixelFormat();
00334     SDLSurface dst = SDL_ConvertSurface(*this, f, src.flags());
00335 
00336     if (dst) {
00337         sdl_surface = dst;
00338         return 0;
00339     }
00340 
00341     return -1;
00342 }

Here is the call graph for this function:

int Wt::SDLSurface::convertToDisplay ( ) [inherited]

Definition at line 344 of file sdlsurface.cpp.

References Wt::SDLSurface::sdl_surface.

00344                                  {
00345     SDLSurface dst = SDL_DisplayFormatAlpha(*this);
00346     if (dst) {
00347         sdl_surface = dst;
00348         return 0;
00349     }
00350 
00351     return -1;
00352 }

int Wt::SDLSurface::defaultDepth ( ) [static, inherited]

Definition at line 373 of file sdlsurface.cpp.

References Wt::Singleton< DERIVED >::instance().

00373                              {
00374     return SDLDisplay::instance()->depth();
00375 }

Here is the call graph for this function:

int Wt::SDLSurface::depth ( ) const [inline, inherited]

Definition at line 154 of file sdlsurface.h.

References Wt::SDLPixelFormat::bitsPerPixel(), and Wt::SDLSurface::pixelFormat().

Referenced by Wt::SDLSurface::blitAlphaCopy(), load(), and Wt::SDLSurface::onDepthChange().

00154                       {
00155         return pixelFormat().bitsPerPixel();
00156     }

Here is the call graph for this function:

void Wt::SDLSurface::detach ( ) [inherited]

Definition at line 51 of file sdlsurface.cpp.

References Wt::SDLSurface::flags(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::blit(), Wt::SDLSurface::clearAlpha(), Wt::SDLSurface::clearTransparentColor(), Wt::SDLSurface::fill(), Wt::SDLSurface::lock(), Wt::SDLSurface::setAlpha(), Wt::SDLSurface::setClipRect(), Wt::SDLSurface::setPalette(), Wt::SDLSurface::setTransparentColor(), and Wt::SDLSurface::unlock().

00051                         {
00052     //avoid detaching if we are the only client for this surface
00053     if (!sdl_surface.unique()) {
00054         /// \bug GCC bug. does not enfoce constness
00055         SDLPixelFormat f = pixelFormat();
00056         sdl_surface.reset(SDL_ConvertSurface(*this, f, flags()), Deleter());
00057     }
00058 }

Here is the call graph for this function:

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::existingInstance ( ) [inline, static, inherited]

Definition at line 36 of file singleton.h.

Referenced by Wt::Application::exit(), Wt::Application::postEvent(), Wt::Application::sendEvent(), and Wt::Application::sendPostedEvents().

00036                                        {
00037         return instance_;
00038     }

int Wt::SDLSurface::fill	(	const SDLRect &	dst,
		int	v
	)			`[inherited]`

Definition at line 202 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00202                                               {
00203     SDLRect r = dst;
00204     detach();
00205     return SDL_FillRect(*this, r, v);
00206 }

Here is the call graph for this function:

int Wt::SDLSurface::fill ( int v ) [inherited]

Definition at line 197 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00197                           {
00198     detach();
00199     return SDL_FillRect(*this, 0, v);
00200 }

Here is the call graph for this function:

int Wt::SDLSurface::flags ( ) const [inline, inherited]

Definition at line 77 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::convertTo(), Wt::SDLSurface::detach(), hasDoubleBuffer(), hasFrame(), hasOpenGL(), hasOpenGLBlit(), isAnyFormat(), isFullScreen(), isResizable(), load(), Wt::SDLSurface::resize(), resize(), and Wt::SDLSurface::setPalette().

00077                       {
00078         return sdl_surface->flags;
00079     }

void Wt::SDLDisplay::flip ( )

If doublebuffered(), flip the surface and its buffer, otherwise update().

Definition at line 63 of file sdldisplay.cpp.

00063                       {
00064     SDL_Flip(*this);
00065 }

bool Wt::SDLSurface::hasAlpha ( ) const [inline, inherited]

Definition at line 109 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::blitAlphaCopy(), and Wt::SDLSurface::isTransparent().

00109                           {
00110         return sdl_surface->flags & SDL_SRCALPHA;
00111     }

bool Wt::SDLSurface::hasAsyncBlit ( ) const [inline, inherited]

Definition at line 89 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00089                               {
00090         return sdl_surface->flags & SDL_ASYNCBLIT;
00091     }

bool Wt::SDLDisplay::hasDoubleBuffer ( ) const [inline]

Definition at line 52 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00052                                  {
00053         return flags() & SDL_DOUBLEBUF;
00054     }

Here is the call graph for this function:

bool Wt::SDLDisplay::hasFrame ( ) const [inline]

Definition at line 72 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00072                           {
00073         return !(flags() & SDL_NOFRAME);
00074     }

Here is the call graph for this function:

bool Wt::SDLSurface::hasHWAcceleration ( ) const [inline, inherited]

Definition at line 97 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00097                                    {
00098         return sdl_surface->flags & SDL_HWACCEL;
00099     }

bool Wt::SDLSurface::hasHWPalette ( ) const [inline, inherited]

Definition at line 93 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00093                               {
00094         return sdl_surface->flags & SDL_HWPALETTE;
00095     }

bool Wt::SDLDisplay::hasOpenGL ( ) const [inline]

Definition at line 60 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00060                            {
00061         return flags() & SDL_OPENGL;
00062     }

Here is the call graph for this function:

bool Wt::SDLDisplay::hasOpenGLBlit ( ) const [inline]

Definition at line 64 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00064                                {
00065         return flags() & SDL_OPENGLBLIT;
00066     }

Here is the call graph for this function:

bool Wt::SDLSurface::hasRLEAccell ( ) const [inline, inherited]

Definition at line 105 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00105                               {
00106         return sdl_surface->flags & SDL_RLEACCEL;
00107     }

bool Wt::SDLSurface::hasTransparentColor ( ) const [inline, inherited]

Definition at line 101 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::blitAlphaCopy(), and Wt::SDLSurface::isTransparent().

00101                                      {
00102         return sdl_surface->flags & SDL_SRCCOLORKEY;
00103     }

int Wt::SDLSurface::height ( ) const [inline, inherited]

Definition at line 142 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::blitAlphaCopy(), Wt::SDLSurface::convertDepth(), Wt::SDLSurface::numBytes(), resize(), Wt::SDLSurface::scale_surface(), Wt::SDLSurface::scaleWidth(), and Wt::SDLSurface::SDLSurface().

00142                        {
00143         return sdl_surface->h;
00144     }

template<class DERIVED>

static void Wt::Singleton< DERIVED >::init ( ) [inline, static, inherited]

Note:: cannot fail

Reimplemented in Wt::Application.

Definition at line 49 of file singleton.h.

Referenced by Wt::Application::Application().

00049                        {
00050         if (!instance()) {
00051             assert(0);
00052         }
00053     }

template<class DERIVED>

template<class GRANDCHILD>

static DERIVED* Wt::Singleton< DERIVED >::instance ( ) [inline, static, inherited]

instantiates the pointer compatible child of DERIVED aka grandchild

it is handy in driver like situations

Definition at line 43 of file singleton.h.

00043                                {
00044         return (instance_) ? instance_ : GRANDCHILD::load();
00045     }

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::instance ( ) [inline, static, inherited]

Definition at line 32 of file singleton.h.

Referenced by Wt::Audio::Audio(), Wt::Sound::available(), Wt::SDLMixer::Chunk::channel(), Wt::NullAudio::Chunk::channel(), Wt::SDLSurface::defaultDepth(), Wt::SDLInput::EventInfo::EventInfo(), Wt::Dialog::exec(), Wt::Widget::grabKeyboard(), Wt::Widget::grabMouse(), Wt::Audio::handleAudioEvent(), Wt::SDLInput::handleKeyEvent(), Wt::Singleton< Wt::Audio >::init(), Wt::SDLTimer::init(), Wt::Sound::isAvailable(), Wt::Widget::keyboardGrabber(), Wt::Audio::load(), Wt::Widget::mouseGrabber(), Wt::SDLMixer::onChannelFinish(), Wt::Audio::onChannelFinish(), Wt::Sound::play(), Wt::Singleton< Wt::Audio >::quit(), Wt::Widget::releaseKeyboard(), Wt::Widget::releaseMouse(), Wt::SDLInput::SDLInput(), Wt::SDLMixer::setMusicVolume(), Wt::SDLMixer::Channel::setVolume(), and Wt::SDLMixer::Chunk::setVolume().

00032                                {
00033         return (instance_) ? instance_ : DERIVED::load();
00034     }

bool Wt::SDLDisplay::isAnyFormat ( ) const [inline]

Definition at line 48 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00048                              {
00049         return flags() & SDL_ANYFORMAT ;
00050     }

Here is the call graph for this function:

bool Wt::SDLDisplay::isFullScreen ( ) const [inline]

Definition at line 56 of file sdldisplay.h.

References Wt::SDLSurface::flags().

00056                               {
00057         return flags() & SDL_FULLSCREEN;
00058     }

Here is the call graph for this function:

bool Wt::SDLSurface::isGrayscale ( ) const [inherited]

Definition at line 161 of file sdlsurface.cpp.

References Wt::SDLSurface::numColors(), Wt::SDLPixelFormat::palette(), and Wt::SDLSurface::pixelFormat().

00161                                    {
00162     SDLPalette pal = pixelFormat().palette();
00163     if (pal) {
00164         int n = numColors();
00165         for (int i = 0; i < n; i++) {
00166             SDLColor c = pal[i];
00167             if (c.red() != c.green() || c.green() != c.blue())
00168                 return false;
00169         }
00170         return true;
00171     } else {}
00172 
00173     return false;
00174 }

Here is the call graph for this function:

bool Wt::SDLSurface::isHWSurface ( ) const [inline, inherited]

Definition at line 85 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00085                              {
00086         return sdl_surface->flags & SDL_HWSURFACE;
00087     }

bool Wt::SDLSurface::isOpaque ( ) const [inline, inherited]

Definition at line 126 of file sdlsurface.h.

References Wt::SDLSurface::isTransparent().

00126                           {
00127         return !isTransparent();
00128     }

Here is the call graph for this function:

bool Wt::SDLSurface::isPreallocated ( ) const [inline, inherited]

Definition at line 130 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00130                                 {
00131         return sdl_surface->flags & SDL_PREALLOC;
00132     }

bool Wt::SDLDisplay::isResizable ( ) const [inline]

Definition at line 68 of file sdldisplay.h.

References Wt::SDLSurface::flags().

Referenced by resize().

00068                              {
00069         return flags() & SDL_RESIZABLE;
00070     }

Here is the call graph for this function:

bool Wt::SDLSurface::isSWSurface ( ) const [inline, inherited]

Definition at line 81 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00081                              {
00082         return sdl_surface->flags & SDL_SWSURFACE;
00083     }

bool Wt::SDLSurface::isTransparent ( ) const [inline, inherited]

There are 3 mechanisms of transparency

ColorKey
Per Surface Alpha
Alpha Channel This function returns true if anyone of them is enabled

Definition at line 120 of file sdlsurface.h.

References Wt::SDLSurface::alpha(), Wt::SDLSurface::hasAlpha(), Wt::SDLSurface::hasTransparentColor(), Wt::SDLColor::Opaque, and Wt::SDLSurface::pixelFormat().

Referenced by Wt::SDLSurface::isOpaque().

00120                                {
00121         return (hasTransparentColor() ||
00122                 (hasAlpha() &&
00123                  (pixelFormat().alphaMask() || alpha() != SDLColor::Opaque)));
00124     }

Here is the call graph for this function:

template<class DERIVED>

static DERIVED* Wt::Singleton< DERIVED >::load ( ) [inline, static, protected, inherited]

try to load the instance

if it fails return NULL if it succeeds must return the newly created object

Reimplemented in Wt::Audio, Wt::NullAudio, and Wt::SDLMixer.

Definition at line 86 of file singleton.h.

00086                            {
00087         instance_ = new DERIVED;
00088         return  instance_;
00089     }

bool Wt::SDLSurface::load	(	const void *	p,
		size_t	size
	)			`[inherited]`

load an image from mem

Definition at line 319 of file sdlsurface.cpp.

References Wt::SDLSurface::sdl_surface.

00319                                                 {
00320     SDLSurface dst = IMG_Load_RW(SDL_RWFromConstMem(p, size), 1);
00321 
00322     if (dst) {
00323         sdl_surface = dst;
00324         return true;
00325     }
00326     return false;
00327 }

bool Wt::SDLSurface::load ( const std::string & fileName ) [inherited]

load an image from a file

Definition at line 309 of file sdlsurface.cpp.

References Wt::SDLSurface::sdl_surface.

00309                                                {
00310     SDLSurface dst = IMG_Load_RW(SDL_RWFromFile(filename.c_str(), "rb"), 1);
00311 
00312     if (dst) {
00313         sdl_surface = dst;
00314         return true;
00315     }
00316     return false;
00317 }

SDLDisplay * Wt::SDLDisplay::load	(	int	w = `defaultWidth`,
		int	h = `defaultHeight`,
		int	depth = `defaultDepth`,
		int	flags = `0`
	)			`[static, protected]`

Definition at line 27 of file sdldisplay.cpp.

References Wt::W::DefaultDisplayPixmapFlags, Wt::SDLSurface::depth(), Wt::SDLSurface::flagMap, Wt::SDLSurface::flags(), Wt::Singleton< DERIVED >::instance_, SDLDisplay(), and Wt::FlagMap::state().

00027                                                                {
00028     SDLSurface s = SDL_SetVideoMode(w, h, depth,
00029                                     flagMap.state(flags ? flags
00030                                               : static_cast<int>(W::DefaultDisplayPixmapFlags)));
00031     instance_ = (s) ? new SDLDisplay(s) : 0;
00032     return instance_;
00033 }

Here is the call graph for this function:

int Wt::SDLSurface::lock ( ) [inherited]

Definition at line 100 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00100                      {
00101     detach()
00102     ;
00103     return SDL_LockSurface(*this);
00104 }

Here is the call graph for this function:

size_t Wt::SDLSurface::numBytes ( ) const [inline, inherited]

Definition at line 182 of file sdlsurface.h.

References Wt::SDLSurface::bytesPerLine(), Wt::SDLPixelFormat::bytesPerPixel(), Wt::SDLSurface::height(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::width().

00182                             {
00183         //return height() * pitch();
00184         return (height() - 1) * bytesPerLine() +
00185                width() * pixelFormat().bytesPerPixel();
00186     }

Here is the call graph for this function:

int Wt::SDLSurface::numColors ( ) const [inherited]

Definition at line 140 of file sdlsurface.cpp.

References Wt::SDLPixelFormat::palette(), Wt::SDLSurface::pixelFormat(), and Wt::SDLPalette::size().

Referenced by Wt::SDLSurface::isGrayscale(), and Wt::SDLSurface::setNumColors().

00140                                 {
00141     SDLPalette pal = pixelFormat().palette();
00142     return (pal) ? pal.size() :  0;
00143 }

Here is the call graph for this function:

void Wt::SDLSurface::onDepthChange ( ) [protected, inherited]

Definition at line 469 of file sdlsurface.cpp.

References Wt::SDLSurface::depth(), Wt::SDLSurface::read_pixel, Wt::SDLSurface::readPixel16bpp(), Wt::SDLSurface::readPixel24bpp(), Wt::SDLSurface::readPixel32bpp(), Wt::SDLSurface::readPixel8bpp(), Wt::SDLSurface::write_pixel, Wt::SDLSurface::writePixel16bpp(), Wt::SDLSurface::writePixel24bpp(), Wt::SDLSurface::writePixel32bpp(), and Wt::SDLSurface::writePixel8bpp().

Referenced by Wt::SDLSurface::SDLSurface().

00469                                {
00470     // don't crash on NULL surfaces
00471     if (!*this)
00472         return;
00473     switch (depth()) {
00474     case 0:
00475         read_pixel = 0;
00476         write_pixel = 0;
00477         assert(0);
00478         break;
00479     case 8:
00480         read_pixel = &SDLSurface::readPixel8bpp;
00481         write_pixel = &SDLSurface::writePixel8bpp;
00482         break;
00483     case 16:
00484         read_pixel = &SDLSurface::readPixel16bpp;
00485         write_pixel = &SDLSurface::writePixel16bpp;
00486         break;
00487     case 24:
00488         read_pixel = &SDLSurface::readPixel24bpp;
00489         write_pixel = &SDLSurface::writePixel24bpp;
00490         break;
00491     case 32:
00492         read_pixel = &SDLSurface::readPixel32bpp;
00493         write_pixel = &SDLSurface::writePixel32bpp;
00494         break;
00495     default:
00496         assert(0);
00497         break;
00498     }
00499 }

Here is the call graph for this function:

Wt::SDLSurface::operator const SDL_Surface * ( ) const [inline, inherited]

Definition at line 67 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00067                                          {
00068         return sdl_surface.get();
00069     }

Wt::SDLSurface::operator SDL_Surface * ( ) [inline, inherited]

Definition at line 71 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00071                               {
00072         return sdl_surface.get();
00073     }

SDLDisplay& Wt::SDLDisplay::operator= ( const SDLDisplay & ) [private]

int Wt::SDLSurface::pixel	(	int	x,
		int	y
	)			const `[inline, inherited]`

Definition at line 286 of file sdlsurface.h.

References Wt::SDLSurface::pixel(), and Wt::SDLSurface::pixelOffset().

00286                                   {
00287         return pixel(pixelOffset(x, y));
00288     }

Here is the call graph for this function:

int Wt::SDLSurface::pixel ( int pixel_offset ) const [inline, inherited]

Definition at line 278 of file sdlsurface.h.

References Wt::SDLSurface::read_pixel.

Referenced by Wt::SDLSurface::pixel(), Wt::SDLSurface::pixelColor(), and Wt::SDLSurface::readPixel24bpp().

00278                                       {
00279         return (this->*read_pixel)(pixel_offset);
00280     }

void* Wt::SDLSurface::pixelAddress	(	int	x,
		int	y
	)			const `[inline, inherited]`

Definition at line 174 of file sdlsurface.h.

References Wt::SDLSurface::pixelOffset(), and Wt::SDLSurface::pixels().

00174                                            {
00175         return (Uint8 *) pixels() + pixelOffset(x, y);
00176     }

Here is the call graph for this function:

void* Wt::SDLSurface::pixelAddress ( int pixel_offset ) const [inline, inherited]

Definition at line 170 of file sdlsurface.h.

References Wt::SDLSurface::pixels().

Referenced by Wt::SDLSurface::readPixel16bpp(), Wt::SDLSurface::readPixel24bpp(), Wt::SDLSurface::readPixel32bpp(), Wt::SDLSurface::readPixel8bpp(), Wt::SDLSurface::scanLine(), Wt::SDLSurface::writePixel16bpp(), Wt::SDLSurface::writePixel24bpp(), Wt::SDLSurface::writePixel32bpp(), and Wt::SDLSurface::writePixel8bpp().

00170                                                {
00171         return (Uint8 *) pixels() + pixel_offset;
00172     }

Here is the call graph for this function:

SDLColor Wt::SDLSurface::pixelColor	(	int	x,
		int	y
	)			const `[inline, inherited]`

Definition at line 290 of file sdlsurface.h.

References Wt::SDLPixelFormat::mapToColor(), Wt::SDLSurface::pixel(), and Wt::SDLSurface::pixelFormat().

00290                                             {
00291         return pixelFormat().mapToColor((pixel(x, y)));
00292     }

Here is the call graph for this function:

SDLColor Wt::SDLSurface::pixelColor ( int pixel_offset ) const [inline, inherited]

Definition at line 282 of file sdlsurface.h.

References Wt::SDLPixelFormat::mapToColor(), Wt::SDLSurface::pixel(), and Wt::SDLSurface::pixelFormat().

00282                                                 {
00283         return pixelFormat().mapToColor((pixel(pixel_offset)));
00284     }

Here is the call graph for this function:

const SDLPixelFormat Wt::SDLSurface::pixelFormat ( ) const [inline, inherited]

int Wt::SDLSurface::pixelOffset	(	int	x,
		int	y
	)			const `[inline, inherited]`

Definition at line 166 of file sdlsurface.h.

References Wt::SDLSurface::bytesPerLine(), Wt::SDLPixelFormat::bytesPerPixel(), and Wt::SDLSurface::pixelFormat().

Referenced by Wt::SDLSurface::pixel(), Wt::SDLSurface::pixelAddress(), and Wt::SDLSurface::setPixel().

00166                                         {
00167         return y * bytesPerLine() + x * pixelFormat().bytesPerPixel();
00168     }

Here is the call graph for this function:

void* Wt::SDLSurface::pixels ( ) [inline, inherited]

Definition at line 158 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

00158                    {
00159         return sdl_surface->pixels;
00160     }

const void* Wt::SDLSurface::pixels ( ) const [inline, inherited]

Definition at line 150 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::bits(), and Wt::SDLSurface::pixelAddress().

00150                                {
00151         return sdl_surface->pixels;
00152     }

template<class DERIVED>

static void Wt::Singleton< DERIVED >::quit ( ) [inline, static, inherited]

Reimplemented in Wt::Application.

Definition at line 55 of file singleton.h.

Referenced by Wt::Application::~Application().

00055                        {
00056         delete instance();
00057     }

int Wt::SDLSurface::readPixel16bpp ( int pixel_offset ) const [protected, inherited]

Definition at line 424 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00424                                                      {
00425     return * (Uint16 *) pixelAddress(pixel_offset);
00426 }

Here is the call graph for this function:

int Wt::SDLSurface::readPixel24bpp ( int pixel_offset ) const [protected, inherited]

Definition at line 432 of file sdlsurface.cpp.

References Wt::SDLPixelFormat::blueShift(), Wt::SDLPixelFormat::greenShift(), Wt::SDLSurface::pixel(), Wt::SDLSurface::pixelAddress(), Wt::SDLSurface::pixelFormat(), and Wt::SDLPixelFormat::redShift().

Referenced by Wt::SDLSurface::onDepthChange().

00432                                                      {
00433     Uint8* screen_loc = (Uint8 *) pixelAddress(pixel_offset);
00434     const SDLPixelFormat f = pixelFormat();
00435     Uint32 pixel = 0;
00436     int shift;
00437 
00438     // I´m not sure on this, Karsten 01/1999
00439     shift = f.redShift();
00440     pixel = *(screen_loc + shift / 8) << shift;
00441     shift = f.greenShift();
00442     pixel |= *(screen_loc + shift / 8) << shift;
00443     shift = f.blueShift();
00444     pixel |= *(screen_loc + shift / 8) << shift;
00445     return pixel;
00446 }

Here is the call graph for this function:

int Wt::SDLSurface::readPixel32bpp ( int pixel_offset ) const [protected, inherited]

Definition at line 461 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00461                                                      {
00462     return * (Uint32 *) pixelAddress(pixel_offset);
00463 }

Here is the call graph for this function:

int Wt::SDLSurface::readPixel8bpp ( int pixel_offset ) const [protected, inherited]

Definition at line 416 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00416                                                     {
00417     return * (Uint8 *) pixelAddress(pixel_offset);
00418 }

Here is the call graph for this function:

void Wt::SDLDisplay::resize	(	int	w,
		int	h
	)

resize the SDL window

Note:: first we delete our reference to VideoSurface before SDL frees it under our feet SDL proctects us from deleting the Display surface and auto deletes it in case we call SDL_SetVideoMode, However SDL does not protect against deletion of the previous VideoSurface.

Reimplemented from Wt::SDLSurface.

Definition at line 82 of file sdldisplay.cpp.

References Wt::SDLPixelFormat::bitsPerPixel(), Wt::SDLSurface::flags(), Wt::SDLSurface::height(), isResizable(), Wt::SDLSurface::pixelFormat(), Wt::SDLSurface::SDLSurface(), trace, and Wt::SDLSurface::width().

00082                                     {
00083     if(!isResizable() || (w == width() && h == height()) || (!w && !h))
00084         return;
00085     SDLSurface& self = *this;
00086     trace("sdlsurface", "Resizing %p to %d x %d\n",
00087           static_cast<SDL_Surface *>(self), w, h);
00088 
00089     /*!\note first we delete our reference to VideoSurface
00090     before SDL frees it under our feet 
00091     SDL proctects us from deleting the Display surface and
00092     auto deletes it in case we call SDL_SetVideoMode, However
00093     SDL does not protect against deletion of the previous
00094     VideoSurface.
00095     */
00096     // first save intersting parameters
00097     int bpp = pixelFormat().bitsPerPixel();
00098     int fl = flags();
00099     self = SDLSurface();
00100     // now set it the resized surface
00101     self = SDL_SetVideoMode(w, h, bpp, fl);
00102 }

Here is the call graph for this function:

SDLSurface Wt::SDLSurface::scale	(	int	w,
		int	h,
		ScaleMode	mode = `ScaleFree`
	)			const `[inherited]`

Definition at line 519 of file sdlsurface.cpp.

References Wt::SDLSurface::scale_surface().

00519                                                                {
00520     return scale_surface(w, h, false, mode);
00521 }

Here is the call graph for this function:

SDLSurface Wt::SDLSurface::scale_surface	(	int	w,
		int	h,
		bool	smooth,
		ScaleMode	mode
	)			const `[protected, inherited]`

Definition at line 501 of file sdlsurface.cpp.

References Wt::deconst(), Wt::SDLSurface::height(), Wt::SDLSurface::ScaleFree, Wt::SDLSurface::ScaleMax, Wt::SDLSurface::ScaleMin, Wt::SDLSurface::SDLSurface(), and Wt::SDLSurface::width().

Referenced by Wt::SDLSurface::scale(), Wt::SDLSurface::scaleHeight(), Wt::SDLSurface::scaleWidth(), and Wt::SDLSurface::smoothScale().

00502                                                                         {
00503     if (mode != ScaleFree && (width() * h != height() * w)) {
00504         double r1 = static_cast<double>(width()) /
00505                     static_cast<double>(height());
00506         double r2 = static_cast<double>(w) /
00507                     static_cast<double>(h);
00508         if ( (mode == ScaleMin & (r2 > r1)) || (mode == ScaleMax & (r2 < r1)) )
00509             w = static_cast<int>(h * r1);
00510         if ( (mode == ScaleMin & (r2 < r1)) || (mode == ScaleMax & (r2 > r1)) )
00511             h = static_cast<int>(w / r1);
00512     }
00513     double zx =  static_cast<double>(w) / static_cast<double>(width());
00514     double zy =  static_cast<double>(h) / static_cast<double>(height());
00515 
00516     return SDLSurface(zoomSurface(deconst(*this), zx, zy, smooth));
00517 }

Here is the call graph for this function:

SDLSurface Wt::SDLSurface::scaleHeight ( int h ) const [inherited]

Definition at line 531 of file sdlsurface.cpp.

References Wt::SDLSurface::scale_surface(), Wt::SDLSurface::ScaleFree, and Wt::SDLSurface::width().

00531                                               {
00532     return scale_surface(width(), h, false, ScaleFree);
00533 }

Here is the call graph for this function:

SDLSurface Wt::SDLSurface::scaleWidth ( int w ) const [inherited]

Definition at line 527 of file sdlsurface.cpp.

References Wt::SDLSurface::height(), Wt::SDLSurface::scale_surface(), and Wt::SDLSurface::ScaleFree.

00527                                              {
00528     return scale_surface(w, height(), false, ScaleFree);
00529 }

Here is the call graph for this function:

void* Wt::SDLSurface::scanLine ( int y ) [inline, inherited]

Definition at line 178 of file sdlsurface.h.

References Wt::SDLSurface::bytesPerLine(), and Wt::SDLSurface::pixelAddress().

00178                           {
00179         return pixelAddress(y * bytesPerLine());
00180     }

Here is the call graph for this function:

int Wt::SDLSurface::serialNumber ( ) const [inline, inherited]

Definition at line 188 of file sdlsurface.h.

00188                              {
00189         return reinterpret_cast<int>(
00190                    static_cast<const SDL_Surface *>(*this));
00191     }

void Wt::SDLSurface::setAlpha ( int alpha = SDLColor::Transparent ) [inherited]

Definition at line 187 of file sdlsurface.cpp.

References Wt::SDLSurface::alpha(), and Wt::SDLSurface::detach().

00187                                    {
00188     detach();
00189     SDL_SetAlpha(*this, SDL_SRCALPHA, alpha);
00190 }

Here is the call graph for this function:

SDLRect Wt::SDLSurface::setClipRect ( const SDLRect & rect ) [inherited]

Definition at line 119 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00119                                                    {
00120     SDLRect r = rect;
00121     detach();
00122     SDL_SetClipRect(*this, r);
00123     return r;
00124 }

Here is the call graph for this function:

void Wt::SDLSurface::setColor	(	int	i,
		const SDLColor &	c
	)			`[inherited]`

Definition at line 135 of file sdlsurface.cpp.

References Wt::SDLSurface::setPalette().

00135                                                   {
00136     std::vector<SDLColor> ca(1, c);
00137     setPalette(ca, i);
00138 }

Here is the call graph for this function:

int Wt::SDLDisplay::setGamma	(	float	red,
		float	green,
		float	blue
	)

Definition at line 67 of file sdldisplay.cpp.

00067                                                   {
00068     return SDL_SetGamma(r, g, b);
00069 }

int Wt::SDLDisplay::setGammaRamp	(	const std::vector< Uint16 > &	red,
		const std::vector< Uint16 > &	green,
		const std::vector< Uint16 > &	blue
	)

???

Definition at line 71 of file sdldisplay.cpp.

00073                                                             {
00074 
00075     return SDL_SetGammaRamp(&red[0], &green[0], &blue[0]);
00076 }

void Wt::SDLSurface::setNumColors ( int ncolors ) [inherited]

Definition at line 145 of file sdlsurface.cpp.

References Wt::SDLSurface::numColors(), Wt::SDLPixelFormat::palette(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::setPalette().

00145                                          {
00146     int old = numColors();
00147 
00148     if (ncolors < old) {
00149         SDLPalette pal = pixelFormat().palette();
00150         std::vector<SDLColor> ca;
00151         ca.reserve(ncolors);
00152         for (int i = 0; i < ncolors; i++)
00153             ca[i] = pal[i];
00154         setPalette(ca, 0);
00155     } else if (ncolors > old) {
00156         std::vector<SDLColor> ca(ncolors - old, SDLColor());
00157         setPalette(ca, old);
00158     }
00159 }

Here is the call graph for this function:

void Wt::SDLSurface::setPalette	(	const std::vector< SDLColor > &	ca,
		int	offset,
		int	flags = `SDLPalette::Logical\|SDLPalette::Physical`
	)			`[inherited]`

Definition at line 126 of file sdlsurface.cpp.

References Wt::SDLSurface::detach(), and Wt::SDLSurface::flags().

Referenced by Wt::SDLSurface::setColor(), and Wt::SDLSurface::setNumColors().

00127                                                    {
00128     //SDL breakage
00129     SDL_Color *colors = const_cast<SDL_Color *>(
00130                             reinterpret_cast<const SDL_Color *>(&ca[0]));
00131     detach();
00132     SDL_SetPalette(*this, flags, colors, offset, ca.size());
00133 }

Here is the call graph for this function:

void Wt::SDLSurface::setPixel	(	int	x,
		int	y,
		int	pixel_value
	)			`[inline, inherited]`

Definition at line 302 of file sdlsurface.h.

References Wt::SDLSurface::pixelOffset(), and Wt::SDLSurface::setPixel().

00302                                                  {
00303         setPixel(pixelOffset(x, y), pixel_value);
00304     }

Here is the call graph for this function:

void Wt::SDLSurface::setPixel	(	int	pixel_offset,
		int	pixel_value
	)			`[inline, inherited]`

Definition at line 294 of file sdlsurface.h.

References Wt::SDLSurface::write_pixel.

Referenced by Wt::SDLSurface::setPixel(), and Wt::SDLSurface::setPixelColor().

00294                                                      {
00295         (this->*write_pixel)(pixel_offset, pixel_value);
00296     }

void Wt::SDLSurface::setPixelColor	(	int	x,
		int	y,
		const SDLColor &	color
	)			`[inline, inherited]`

Definition at line 306 of file sdlsurface.h.

References Wt::SDLSurface::color(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::setPixel().

00306                                                             {
00307         setPixel(x, y, pixelFormat().mapToPixelValue(color));
00308     }

Here is the call graph for this function:

void Wt::SDLSurface::setPixelColor	(	int	pixel_offset,
		const SDLColor &	color
	)			`[inline, inherited]`

Definition at line 298 of file sdlsurface.h.

References Wt::SDLSurface::color(), Wt::SDLSurface::pixelFormat(), and Wt::SDLSurface::setPixel().

00298                                                                 {
00299         setPixel(pixel_offset, pixelFormat().mapToPixelValue(color));
00300     }

Here is the call graph for this function:

void Wt::SDLSurface::setTransparentColor ( const SDLColor & color = SDLColor() ) [inherited]

Definition at line 176 of file sdlsurface.cpp.

References Wt::SDLSurface::color(), Wt::SDLSurface::detach(), and Wt::SDLSurface::pixelFormat().

00176                                                           {
00177     detach();
00178     SDL_SetColorKey(*this, SDL_SRCCOLORKEY | SDL_RLEACCEL,
00179                     pixelFormat().mapToPixelValue(color));
00180 }

Here is the call graph for this function:

SDLSurface Wt::SDLSurface::smoothScale	(	int	w,
		int	h,
		ScaleMode	mode = `ScaleFree`
	)			const `[inherited]`

Definition at line 523 of file sdlsurface.cpp.

References Wt::SDLSurface::scale_surface().

00523                                                                      {
00524     return scale_surface(w, h, true, mode);
00525 }

Here is the call graph for this function:

static int Wt::SDLSurface::systemBitOrder ( ) [inline, static, inherited]

Determines the bit order of the display hardware.

Definition at line 318 of file sdlsurface.h.

00318                                 {
00319         return SDL_BYTEORDER;
00320     }

static int Wt::SDLSurface::systemByteOrder ( ) [inline, static, inherited]

Determines the byte order of the display hardware.

Definition at line 313 of file sdlsurface.h.

00313                                  {
00314         return SDL_BYTEORDER;
00315     }

int Wt::SDLDisplay::toggleFullScreen ( )

returns true if the surface is full screen

Definition at line 78 of file sdldisplay.cpp.

00078                                  {
00079     return SDL_WM_ToggleFullScreen(*this);
00080 }

SDLColor Wt::SDLSurface::transparentColor ( ) const [inline, inherited]

Definition at line 218 of file sdlsurface.h.

References Wt::SDLSurface::pixelFormat(), and Wt::SDLPixelFormat::transparentColor().

00218                                       {
00219         return pixelFormat().transparentColor();
00220     }

Here is the call graph for this function:

int Wt::SDLSurface::unlock ( ) [inherited]

Definition at line 106 of file sdlsurface.cpp.

References Wt::SDLSurface::detach().

00106                        {
00107     detach();
00108     SDL_UnlockSurface(*this);
00109     return 0;
00110 }

Here is the call graph for this function:

void Wt::SDLDisplay::update ( const std::vector< SDLRect > & rects )

Update a region on the surface.

Definition at line 54 of file sdldisplay.cpp.

00054                                                        {
00055     if (!rects.size()) // could cause a problem with zero size array
00056         return;
00057 
00058     const SDL_Rect *rc = rects[0];
00059     SDL_Rect *r = const_cast<SDL_Rect *>(rc);
00060     SDL_UpdateRects(*this, rects.size(), r);
00061 }

void Wt::SDLDisplay::update ( const SDLRect & rect )

Update a rectangle on the surface.

Definition at line 50 of file sdldisplay.cpp.

References Wt::SDLRect::height(), Wt::SDLRect::width(), Wt::SDLRect::x(), and Wt::SDLRect::y().

00050                                         {
00051     SDL_UpdateRect(*this, r.x(), r.y(), r.width(), r.height());
00052 }

Here is the call graph for this function:

void Wt::SDLDisplay::update ( )

Update the surface.

Definition at line 46 of file sdldisplay.cpp.

00046                         {
00047     SDL_UpdateRect(*this, 0, 0, 0, 0);
00048 }

int Wt::SDLSurface::width ( ) const [inline, inherited]

Definition at line 138 of file sdlsurface.h.

References Wt::SDLSurface::sdl_surface.

Referenced by Wt::SDLSurface::blitAlphaCopy(), Wt::SDLSurface::convertDepth(), Wt::SDLSurface::numBytes(), resize(), Wt::SDLSurface::scale_surface(), Wt::SDLSurface::scaleHeight(), and Wt::SDLSurface::SDLSurface().

00138                       {
00139         return sdl_surface->w;
00140     }

void Wt::SDLSurface::writePixel16bpp	(	int	pixel_offset,
		int	pixel_value
	)			`[protected, inherited]`

Definition at line 428 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00428                                                                   {
00429     * (Uint16 *) pixelAddress(pixel_offset) = pixel_value;
00430 }

Here is the call graph for this function:

void Wt::SDLSurface::writePixel24bpp	(	int	pixel_offset,
		int	pixel_value
	)			`[protected, inherited]`

Definition at line 448 of file sdlsurface.cpp.

References Wt::SDLPixelFormat::blueShift(), Wt::SDLPixelFormat::greenShift(), Wt::SDLSurface::pixelAddress(), Wt::SDLSurface::pixelFormat(), and Wt::SDLPixelFormat::redShift().

Referenced by Wt::SDLSurface::onDepthChange().

00448                                                                   {
00449     Uint8* screen_loc = (Uint8 *) pixelAddress(pixel_offset);
00450     int shift;
00451     const SDLPixelFormat f = pixelFormat();
00452 
00453     shift = f.redShift();
00454     *(screen_loc + shift / 8) =  pixel_value >> shift;
00455     shift = f.greenShift();
00456     *(screen_loc + shift / 8) =  pixel_value >> shift;
00457     shift = f.blueShift();
00458     *(screen_loc + shift / 8) =  pixel_value >> shift;
00459 }

Here is the call graph for this function:

void Wt::SDLSurface::writePixel32bpp	(	int	pixel_offset,
		int	pixel_value
	)			`[protected, inherited]`

Definition at line 465 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00465                                                                   {
00466     * (Uint32 *) pixelAddress(pixel_offset) = pixel_value;
00467 }

Here is the call graph for this function:

void Wt::SDLSurface::writePixel8bpp	(	int	pixel_offset,
		int	pixel_value
	)			`[protected, inherited]`

Definition at line 420 of file sdlsurface.cpp.

References Wt::SDLSurface::pixelAddress().

Referenced by Wt::SDLSurface::onDepthChange().

00420                                                                  {
00421     * (Uint8 *) pixelAddress(pixel_offset) = pixel_value;
00422 }

Here is the call graph for this function:

friend class Singleton< SDLDisplay > [friend]

Definition at line 32 of file sdldisplay.h.

const FlagMap Wt::SDLSurface::flagMap [static, protected, inherited]

Initial value:

 boost::assign::map_list_of
                                    (W::SWSurface, SDL_SWSURFACE)
                                    (W::HWSurface, SDL_HWSURFACE)
                                    (W::AsyncBlit, SDL_ASYNCBLIT)
                                    (W::HWPalette, SDL_HWPALETTE)
                                    (W::HWAccel, SDL_HWACCEL)
                                    (W::AnyFormat, SDL_ANYFORMAT)
                                    (W::DoubleBuffer, SDL_DOUBLEBUF)
                                    (W::FullScreen, SDL_FULLSCREEN)
                                    (W::OpenGL, SDL_OPENGL)
                                    (W::OpenGLBlit, SDL_OPENGLBLIT)
                                    (W::Resizable, SDL_RESIZABLE)
                                    (W::NoFrame, SDL_NOFRAME)

Definition at line 336 of file sdlsurface.h.

Referenced by load().

template<class DERIVED>

DERIVED * Wt::Singleton< DERIVED >::instance_ = 0 [static, protected, inherited]

Definition at line 91 of file singleton.h.

Referenced by Wt::Singleton< Wt::Audio >::existingInstance(), Wt::Singleton< Wt::Audio >::instance(), Wt::Singleton< Wt::Audio >::load(), load(), Wt::Audio::load(), Wt::Singleton< Wt::Audio >::Singleton(), and Wt::Singleton< Wt::Audio >::~Singleton().

Wt::SDLDisplay Class Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Static Protected Attributes

Private Member Functions

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation


Public Types
	defaultWidth = 640
	defaultHeight = 480
	defaultDepth = 32
enum	DefaultSurface { defaultWidth = 640, defaultHeight = 480, defaultDepth = 32 }
	IgnoreEndian
	BigEndian = SDL_BIG_ENDIAN
	LittleEndian = SDL_LIL_ENDIAN
	ScaleFree
	ScaleMin
	ScaleMax
enum	Endian { IgnoreEndian, BigEndian = SDL_BIG_ENDIAN, LittleEndian = SDL_LIL_ENDIAN }
enum	ScaleMode { ScaleFree, ScaleMin, ScaleMax }
Public Member Functions
	SDLDisplay (int w=defaultWidth, int h=defaultHeight, int depth=defaultDepth, int flags=0)
	Initialize the target screen surface.
	operator const SDL_Surface * () const
	operator SDL_Surface * ()
int	lock ()
int	unlock ()
void	detach ()
int	pixel (int pixel_offset) const
int	pixel (int x, int y) const
SDLColor	pixelColor (int pixel_offset) const
SDLColor	pixelColor (int x, int y) const
void	setPixel (int pixel_offset, int pixel_value)
void	setPixel (int x, int y, int pixel_value)
void	setPixelColor (int pixel_offset, const SDLColor &color)
void	setPixelColor (int x, int y, const SDLColor &color)
Informative methods
bool	isAnyFormat () const
bool	hasDoubleBuffer () const
bool	isFullScreen () const
bool	hasOpenGL () const
bool	hasOpenGLBlit () const
bool	isResizable () const
bool	hasFrame () const
update methods
void	update ()
	Update the surface.
void	update (const SDLRect &rect)
	Update a rectangle on the surface.
void	update (const std::vector< SDLRect > &rects)
	Update a region on the surface.
void	flip ()
	If doublebuffered(), flip the surface and its buffer, otherwise update().
Gamma methods
int	setGamma (float red, float green, float blue)
int	setGammaRamp (const std::vector< Uint16 > &red, const std::vector< Uint16 > &green, const std::vector< Uint16 > &blue)
	???
resize methods
int	toggleFullScreen ()
	returns true if the surface is full screen
void	resize (int w, int h)
	resize the SDL window
Informative methods
int	flags () const
bool	isSWSurface () const
bool	isHWSurface () const
bool	hasAsyncBlit () const
bool	hasHWPalette () const
bool	hasHWAcceleration () const
bool	hasTransparentColor () const
bool	hasRLEAccell () const
bool	hasAlpha () const
bool	isTransparent () const
bool	isOpaque () const
bool	isPreallocated () const
const SDLPixelFormat	pixelFormat () const
int	width () const
int	height () const
int	bytesPerLine () const
const void *	pixels () const
void *	pixels ()
int	depth () const
void *	bits ()
int	pixelOffset (int x, int y) const
void *	pixelAddress (int pixel_offset) const
void *	pixelAddress (int x, int y) const
void *	scanLine (int y)
size_t	numBytes () const
int	serialNumber () const
Clipping Methods
SDLRect	clipRect () const
SDLRect	setClipRect (const SDLRect &rect)
Colors and transparency methods
void	setPalette (const std::vector< SDLColor > &ca, int offset, int flags=SDLPalette::Logical\|SDLPalette::Physical)
SDLColor	color (int index) const
void	setColor (int i, const SDLColor &c)
int	numColors () const
void	setNumColors (int ncolors)
bool	isGrayscale () const
void	setTransparentColor (const SDLColor &color=SDLColor())
void	clearTransparentColor ()
SDLColor	transparentColor () const
void	setAlpha (int alpha=SDLColor::Transparent)
void	clearAlpha ()
int	alpha () const
Painting and blitting methods
int	fill (int v)
int	fill (const SDLRect &dst, int v)
int	blit (const SDLSurface &src)
	full blit
int	blit (int x, int y, const SDLSurface &src)
	blit to
int	blit (int x, int y, const SDLSurface &src, const SDLRect &src_rect)
	blit to from
int	blitAlphaCopy (const SDLSurface &src)
	copy to from src
int	blitAlphaCopy (int x, int y, const SDLSurface &src)
	copy to from src
int	blitAlphaCopy (int x, int y, const SDLSurface &src, const SDLRect &src_rect)
	copy to from src rect
bool	load (const std::string &fileName)
	load an image from a file
bool	load (const void *p, size_t size)
	load an image from mem
Scaling methods
SDLSurface	scale (int w, int h, ScaleMode mode=ScaleFree) const
SDLSurface	smoothScale (int w, int h, ScaleMode mode=ScaleFree) const
SDLSurface	scaleWidth (int w) const
SDLSurface	scaleHeight (int h) const
Surface conversion methods
int	convertTo (const SDLSurface src)
int	convertToDisplay ()
int	convertDepth (int new_depth)
Static Public Member Functions
static int	defaultDepth ()
static int	systemByteOrder ()
	Determines the byte order of the display hardware.
static int	systemBitOrder ()
	Determines the bit order of the display hardware.
static DERIVED *	instance ()
template<class GRANDCHILD>
static DERIVED *	instance ()
	instantiates the pointer compatible child of DERIVED aka grandchild
static DERIVED *	existingInstance ()
static void	init ()
static void	quit ()
Protected Member Functions
	SDLDisplay (SDLSurface &src)
	copy constructor takes ownership. It is called from load()
int	readPixel8bpp (int pixel_offset) const
void	writePixel8bpp (int pixel_offset, int pixel_value)
int	readPixel16bpp (int pixel_offset) const
void	writePixel16bpp (int pixel_offset, int pixel_value)
int	readPixel24bpp (int pixel_offset) const
void	writePixel24bpp (int pixel_offset, int pixel_value)
int	readPixel32bpp (int pixel_offset) const
void	writePixel32bpp (int pixel_offset, int pixel_value)
void	onDepthChange ()
SDLSurface	scale_surface (int w, int h, bool smooth, ScaleMode mode) const
Static Protected Member Functions
static SDLDisplay *	load (int w=defaultWidth, int h=defaultHeight, int depth=defaultDepth, int flags=0)
static DERIVED *	load ()
	try to load the instance
Static Protected Attributes
static const FlagMap	flagMap
static DERIVED *	instance_ = 0
Private Member Functions
	SDLDisplay (const SDLDisplay &)
SDLDisplay &	operator= (const SDLDisplay &)
Friends
class	Singleton< SDLDisplay >