sdlsurface.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  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., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_SDLSURFACE_H
#define WT_SDLSURFACE_H

// SDL_Surface
#include <SDL/SDL_video.h>
#include <SDL/SDL_endian.h>

#include <vector>

#include <boost/shared_ptr.hpp>

#include "sdlrect.h"
#include "sdlpixelformat.h"
#include "flagmap.h"
#include <wt/flags.h>

namespace Wt {

/* this is a thin layer without object management
around SDL_Surface pointer */
class SDLSurface {

public:
    typedef enum {
        IgnoreEndian,
        BigEndian = SDL_BIG_ENDIAN,
        LittleEndian = SDL_LIL_ENDIAN
    } Endian;

    typedef enum {
        ScaleFree,
        ScaleMin,
        ScaleMax
    } ScaleMode;

    /// constructor for a sized surface
    SDLSurface(int w, int h, int depth = -1, int flags = 0);

    /// constructor from SDL_Surface. we take over ownership
    SDLSurface(SDL_Surface* surface = 0);

    /// constructor from file
    SDLSurface(const std::string& filename);

public:
    //cast operators for automatic downcasting of our childs
    operator const SDL_Surface* () const {
        return sdl_surface.get();
    }

    operator SDL_Surface* ()  {
        return sdl_surface.get();
    }

    //! \name Informative methods
    //@{
    int flags() const {
        return sdl_surface->flags;
    }

    bool isSWSurface() const {
        return sdl_surface->flags & SDL_SWSURFACE;
    }

    bool isHWSurface() const {
        return sdl_surface->flags & SDL_HWSURFACE;
    }

    bool hasAsyncBlit() const {
        return sdl_surface->flags & SDL_ASYNCBLIT;
    }

    bool hasHWPalette() const {
        return sdl_surface->flags & SDL_HWPALETTE;
    }

    bool hasHWAcceleration() const {
        return sdl_surface->flags & SDL_HWACCEL;
    }

    bool hasTransparentColor() const {
        return sdl_surface->flags & SDL_SRCCOLORKEY;
    }

    bool hasRLEAccell() const {
        return sdl_surface->flags & SDL_RLEACCEL;
    }

    bool hasAlpha() const {
        return sdl_surface->flags & SDL_SRCALPHA;
    }

    /*! There are 3 mechanisms of transparency
     - ColorKey
     - Per Surface Alpha
     - Alpha Channel
     This function returns true if anyone of
    them is enabled
    */
    bool isTransparent() const {
        return (hasTransparentColor() ||
                (hasAlpha() &&
                 (pixelFormat().alphaMask() || alpha() != SDLColor::Opaque)));
    }

    bool isOpaque() const {
        return !isTransparent();
    }

    bool isPreallocated() const {
        return sdl_surface->flags & SDL_PREALLOC;
    }

    const SDLPixelFormat pixelFormat() const {
        return sdl_surface->format;
    }

    int width() const {
        return sdl_surface->w;
    }

    int height() const {
        return sdl_surface->h;
    }

    int bytesPerLine() const {
        return sdl_surface->pitch;
    }

    const void *pixels() const {
        return sdl_surface->pixels;
    }

    int depth() const {
        return pixelFormat().bitsPerPixel();
    }

    void *pixels() {
        return sdl_surface->pixels;
    }

    void *bits() {
        return pixels();
    }

    int pixelOffset(int x, int y) const {
        return y * bytesPerLine() + x * pixelFormat().bytesPerPixel();
    }

    void *pixelAddress(int pixel_offset) const {
        return (Uint8 *) pixels() + pixel_offset;
    }

    void *pixelAddress(int x, int y) const {
        return (Uint8 *) pixels() + pixelOffset(x, y);
    }

    void *scanLine(int y) {
        return pixelAddress(y * bytesPerLine());
    }

    size_t numBytes() const {
        //return height() * pitch();
        return (height() - 1) * bytesPerLine() +
               width() * pixelFormat().bytesPerPixel();
    }

    int serialNumber() const {
        return reinterpret_cast<int>(
                   static_cast<const SDL_Surface *>(*this));
    }
    //@}

    //! \name Clipping Methods
    //@{
    SDLRect clipRect() const;
    SDLRect setClipRect(const SDLRect& rect);
    //@}

    //! \name Colors and transparency methods
    //@{
    void setPalette(const std::vector<SDLColor>& ca, int offset,
                    int flags = SDLPalette::Logical | SDLPalette::Physical);

    SDLColor color(int index) const {
        return pixelFormat().palette()[index];
    }

    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 {
        return pixelFormat().transparentColor();
    }

    void setAlpha(int alpha = SDLColor::Transparent);
    void clearAlpha();
    int alpha() const {
        return pixelFormat().alpha();
    }

    //@}

    int lock()
        ;
    int unlock();

    //! \name Painting and blitting methods
    //@{
    int fill(int v);

    int fill(const SDLRect& dst, int v);

    /// full blit
    int blit(const SDLSurface& src);
    /// blit to
    int blit(int x, int y, const SDLSurface& src);
    /// blit to from
    int blit(int x, int y, const SDLSurface& src, const SDLRect& src_rect);

    /// copy to from src
    int blitAlphaCopy(const SDLSurface& src);
    /// copy to from src
    int blitAlphaCopy(int x, int y, const SDLSurface& src);
    /// copy to from src rect
    int blitAlphaCopy(int x, int y, const SDLSurface& src, const SDLRect& src_rect);

    /// load an image from a file
    bool load(const std::string& fileName);
    /// load an image from mem
    bool load(const void *p, size_t size);
    //@}

    //! \name 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;
    //@}

    //! \name Surface conversion methods
    //@{
    int convertTo(const SDLSurface src);
    int convertToDisplay();
    int convertDepth(int new_depth);
    void resize(int x, int y);
    //@}

    void detach();

    int pixel(int pixel_offset) const {
        return (this->*read_pixel)(pixel_offset);
    }

    SDLColor pixelColor(int pixel_offset) const {
        return pixelFormat().mapToColor((pixel(pixel_offset)));
    }

    int pixel(int x, int y) const {
        return pixel(pixelOffset(x, y));
    }

    SDLColor pixelColor(int x, int y) const {
        return pixelFormat().mapToColor((pixel(x, y)));
    }

    void setPixel(int pixel_offset, int pixel_value) {
        (this->*write_pixel)(pixel_offset, pixel_value);
    }

    void setPixelColor(int pixel_offset, const SDLColor& color) {
        setPixel(pixel_offset, pixelFormat().mapToPixelValue(color));
    }

    void setPixel(int x, int y, int pixel_value) {
        setPixel(pixelOffset(x, y), pixel_value);
    }

    void setPixelColor(int x, int y, const SDLColor& color) {
        setPixel(x, y, pixelFormat().mapToPixelValue(color));
    }

    static int defaultDepth();

    /// Determines the byte order of the display hardware
    static int systemByteOrder() {
        return SDL_BYTEORDER;
    }

    /// Determines the bit order of the display hardware
    static int systemBitOrder() {
        return SDL_BYTEORDER;
    }

protected:
    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 const FlagMap flagMap;

private:
    /// wraps up the surface deletion so we can use
    /// boost smart pointers with it
    class Deleter {
    public:
        void operator()(SDL_Surface* s);
    };

    typedef boost::shared_ptr<SDL_Surface> Ptr;
    Ptr sdl_surface;

    //provided for convenience only and for in class usage
    operator const Ptr () const {
        return sdl_surface;
    }

    operator Ptr ()  {
        return sdl_surface;
    }

    typedef int (SDLSurface::*readPixelFunction)(int) const;
    typedef void (SDLSurface::*writePixelFunction)(int, int);

    readPixelFunction read_pixel;
    writePixelFunction write_pixel;
};

} // namespace Wt

#endif // WT_SDLSURFACE_H

---

Generated Fri Jul 28 19:23:01 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.