pixmap.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_PIXMAP_H
#define WT_PIXMAP_H

#include <wt/region.h>
#include <wt/color.h>

#include "sdlsurface.h"

namespace Wt {

/// used as a base for the Pixmap and the Display
/*! \note SDLPixmap must be a SDLSurface descendant */
template <typename SDLPixmap>
class PixmapOf: public SDLPixmap {
protected:
    typedef PixmapOf<SDLSurface> PixmapBase;

public:
    /// constructor for NULL pixmap or default display
    PixmapOf()
            : SDLPixmap() {}
    /// constructor for a sized display
    PixmapOf(int w, int h, int depth, int flags = 0)
            : SDLPixmap(w, h, depth, flags) {}
    /// constructor for a sized display
    PixmapOf(const Size& size, int depth, int flags = 0)
            : SDLPixmap(size.width(), size.height(), depth, flags) {}

    /// copy shares the pixmap
    PixmapOf(const PixmapBase& pixmap)
            : SDLSurface(pixmap) {}
    /// constructor from SDLSurface (for scale to work implicitely)
    PixmapOf(const SDLSurface& sdlsurface)
            : SDLSurface(sdlsurface) {}
    /// constructor from file
    PixmapOf(const std::string& filename)
            : SDLSurface(filename) {}

    //! \name Informative methods
    //@{
    bool isNull() const {
        return (!*this || (SDLPixmap::width() == 0 && SDLPixmap::height() == 0));
    }

    Size size() const {
        return Size(SDLPixmap::width(), SDLPixmap::height());
    }

    Rect rect() const {
        return Rect(0, 0, SDLPixmap::width(), SDLPixmap::height());
    }
    //@}

    using SDLPixmap::fill;
    void fill(const Color& color = Color("white")) {
        fill(SDLPixmap::pixelFormat().mapToPixelValue(color));
    }
    void fill(const Rect& dst, const Color& color = Color("white")) {
        fill(dst, SDLPixmap::pixelFormat().mapToPixelValue(color));
    }

    void fill(const Region& dst, const Color& color = Color("white")) {
        const RectArray& ra = dst.rects();
        const int n = ra.size();

        for (int i = 0; i < n; i++) {
            fill(ra[i], color);
        }
    }

    void blend(const Color& color = Color("white"),
               int alpha_blend_factor = Color::Transparent) {
        blend(rect(), SDLPixmap::pixelFormat().mapToPixelValue(color), alpha_blend_factor);
    }

    void blend(const Rect& dst, const Color& color = Color("white"),
               int alpha_blend_factor = Color::Transparent) {

        switch(color.alpha()) {
        case Color::Transparent:
            return;
        case Color::Opaque:
            fill(dst, color);
            return;
        default:
            break;
        }

        const Rect overlap = dst.intersect(SDLPixmap::clipRect());
        if(overlap.isEmpty())
            return;

        int new_part, old_part;
        Color::calcBlendFactors(color.alpha(), new_part, old_part);
        int alpha_new_part, alpha_old_part;
        Color::calcBlendFactors(alpha_blend_factor, alpha_new_part, alpha_old_part);

        SDLPixmap::lock()
            ;
        const int bpp = SDLPixmap::pixelFormat().bytesPerPixel();
        for(int y = overlap.y(); y < overlap.y() + overlap.height(); y++) {
            int offset = SDLPixmap::pixelOffset(overlap.x(), y);
            for(int x = overlap.x(); x < overlap.x() + overlap.width(); x++) {

                Color c = SDLPixmap::pixelColor(offset);
                c = Color::blend(c, old_part, color, new_part,
                                 alpha_new_part, alpha_old_part);

                SDLPixmap::setPixelColor(offset, c);
                offset += bpp;
            }
        }
        SDLPixmap::unlock();

        return;
    }

    void blend(const Region& dst, const Color& color = Color("white"),
               int alpha_blend_factor = Color::Transparent) {
        const RectArray& ra = dst.rects();
        const int n = ra.size();

        for (int i = 0; i < n; i++) {
            blend(ra[i], color, alpha_blend_factor);
        }
    }

    using SDLPixmap::blit;
    int blit(const Point& p, const PixmapBase& src) {
        return blit(p.x(), p.y(), src);
    }
    int blit(const Point& p, const PixmapBase& src, const Rect& src_rect) {
        return blit(p.x(), p.y(), src, src_rect);
    }

    using SDLPixmap::blitAlphaCopy;
    int blitAlphaCopy(const Point& p, const PixmapBase& src) {
        return blitAlphaCopy(p.x(), p.y(), src);
    }
    int blitAlphaCopy(const Point& p, const PixmapBase& src, const Rect& src_rect) {
        return blitAlphaCopy(p.x(), p.y(), src, src_rect);
    }

    /// copy to from src rect with alpha blending
    /*!
    if alpha_blend_factor = Color::Transparent (default) we keep the
    destination alpha (blit semantics). If it is set to Color::Opaque
    we replace alpha values with the new one (blitAlphaCopy semantics).

    The blending of the color happens anyway.
    */
    int blitAlphaBlend(int x, int y, const PixmapBase& src,
                       const Rect& src_rect,
                       int alpha_blend_factor = Color::Transparent) {
        const Rect dst = Rect(x, y, src_rect.width(), src_rect.height());
        const Rect overlap = dst.intersect(SDLPixmap::clipRect());

        if(overlap.isEmpty())
            return 0;

        assert(SDLPixmap::depth() == src.depth());

        const int bpp = SDLPixmap::pixelFormat().bytesPerPixel();
        const int src_bpp = src.pixelFormat().bytesPerPixel();

        int alpha_new_part, alpha_old_part;
        Color::calcBlendFactors(alpha_blend_factor, alpha_new_part, alpha_old_part);
        SDLPixmap::lock()
            ;
        for(int y = overlap.y(); y < overlap.y() + overlap.height(); y++) {
            int offset = SDLPixmap::pixelOffset(overlap.x(), y);
            int src_offset = src.pixelOffset(src_rect.x(), src_rect.y() + y - overlap.y());
            for(int x = overlap.x(); x < overlap.x() + overlap.width(); x++) {
                Color c = pixelColor(offset);
                Color src_c = src.pixelColor(src_offset);

                int new_part, old_part;
                Color::calcBlendFactors(src_c.alpha(), new_part, old_part);
                c = Color::blend(c, old_part, src_c, new_part,
                                 alpha_new_part, alpha_old_part);
                SDLPixmap::setPixelColor(offset, c);

                offset += bpp;
                src_offset += src_bpp;
            }
        }
        SDLPixmap::unlock();

        return 0;
    }

    /// copy to from src with alpha blending
    int blitAlphaBlend(const PixmapBase& src,
                       int alpha_blend_factor = Color::Transparent) {
        return blitAlphaBlend(0, 0, src,
                              Rect(0, 0, src.width(), src.height()),
                              alpha_blend_factor);
    }
    /// copy to from src with alpha blending
    int blitAlphaBlend(int x, int y, const PixmapBase& src,
                       int alpha_blend_factor = Color::Transparent) {
        return blitAlphaBlend(x, y, src,
                              Rect(0, 0, src.width(), src.height()),
                              alpha_blend_factor);
    }
    int blitAlphaBlend(const Point& p, const PixmapBase& src,
                       int alpha_blend_factor = Color::Transparent) {
        return blitAlphaBlend(p.x(), p.y(), src, alpha_blend_factor);
    }
    int blitAlphaBlend(const Point& p, const PixmapBase& src, const Rect& src_rect,
                       int alpha_blend_factor = Color::Transparent) {
        return blitAlphaBlend(p.x(), p.y(), src, src_rect, alpha_blend_factor);
    }

    using SDLPixmap::resize;
    void resize(const Size& size) {
        resize(size.width(), size.height());
    }

    using SDLPixmap::scale;
    PixmapBase scale(const Size& size,
                     SDLSurface::ScaleMode mode = SDLSurface::ScaleFree) const {
        return scale(size.width(), size.height(), mode);
    }

    using SDLPixmap::smoothScale;
    PixmapBase smoothScale(const Size& size,
                           SDLSurface::ScaleMode mode = SDLSurface::ScaleFree) const {
        return smoothScale(size.width(), size.height(), mode);
    }

    using SDLPixmap::pixel;
    int pixel(const Point& p) const {
        return pixel(p.x(), p.y());
    }

    using SDLPixmap::pixelColor;
    Color pixelColor(const Point& p) const {
        return pixelColor(p.x(), p.y());
    }

    using SDLPixmap::setPixel;
    void setPixel(const Point& p, int pixel_value) {
        setPixel(p.x(), p.y(), pixel_value);
    }

    using SDLPixmap::setPixelColor;
    void setPixelColor(const Point& p, const SDLColor& color) {
        setPixelColor(p.x(), p.y(), color);
    }

    PixmapBase copy() const {
        return copy(rect());
    }

    PixmapBase copy(int x, int y, int w, int h) const {
        return copy(Rect(x, y, w, h));
    }

    PixmapBase copy(const Rect& r) const {
        PixmapBase p(r.width(), r.height());
        p.convertTo(*this);
        p.blit(0, 0, *this, r);
        return p;
    }
};

class Pixmap : public PixmapOf<SDLSurface> {
public:
    typedef enum {
        NoOptim,
        BestOptim,
        DefaultOptim = BestOptim
    } Optimization;

    /// constructor for NULL pixmap or default display
    Pixmap()
            : PixmapBase() {}

    /// constructor for a sized, non display, pixmap
    Pixmap(int w, int h, int depth = -1, int flags = 0, Optimization optimization = DefaultOptim)
            :  PixmapOf<SDLSurface>(w, h, depth, flags) {
        if (optimization == BestOptim)
            convertToDisplay();
    }
    /// constructor for a sized, non display, pixmap
    Pixmap(const Size& size, int depth = -1, int flags = 0, Optimization optimization = DefaultOptim)
            :  PixmapOf<SDLSurface>(size.width(), size.height(), depth, flags) {
        if (optimization == BestOptim)
            convertToDisplay();
    }

    /// copy shares the pixmap
    Pixmap(const PixmapBase& pixmap)
        : PixmapBase(pixmap) {}
    /// constructor from SDLSurface (for scale to work implicitely)
    Pixmap(const SDLSurface& sdlsurface)
            : PixmapBase(sdlsurface) {}
    /// constructor from file
    Pixmap(const std::string& filename)
            : PixmapBase(filename) {}
}
;

} // namespace Wt

#endif // WT_PIXMAP_H

---

Generated Fri Jul 28 19:23:00 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.