sdlcolor.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_SDLCOLOR_H
#define WT_SDLCOLOR_H

#include <iosfwd>
#include <cassert>

#include <SDL/SDL_video.h>

namespace Wt {

/*!
\note don't change object size to keep SDL_Color compatibility.
that means:
 - no new data members
 - no virtual functions
*/
class SDLColor {
public:
    /// Default constructor (opaque black)
    SDLColor() {
        assert(sizeof(SDLColor) == sizeof(SDL_Color));
        setColor(0, 0, 0, Opaque);
    }

    /// Construct from a triple/quadruple. (R, G, B, A)
    SDLColor(int red, int green, int blue, int alpha = Opaque) {
        assert(sizeof(SDLColor) == sizeof(SDL_Color));
        setColor(red, green, blue, alpha);
    }

    /// constructor from a base object
    SDLColor(const SDL_Color& color)
            : sdl_color(color) {
        assert(sizeof(SDLColor) == sizeof(SDL_Color));
    }

    /// assign operator
    SDLColor& operator=(const SDL_Color& color) {
        sdl_color = color;
        return *this;
    }

    operator const SDL_Color& () const {
        return sdl_color;
    }

    operator SDL_Color& ()  {
        return sdl_color;
    }

    int red() const {
        return sdl_color.r;
    }

    int green() const {
        return sdl_color.g;
    }

    int blue() const {
        return sdl_color.b;
    }

    int alpha() const {
        return sdl_color.unused;
    }

    void setRed(int red) {
        sdl_color.r = red;
    }

    void setGreen(int green) {
        sdl_color.g = green;
    }

    void setBlue(int blue) {
        sdl_color.b = blue;
    }

    void setAlpha(int alpha) {
        sdl_color.unused = alpha;
    }

    void setColor(int red, int green, int blue, int alpha) {
        setRed(red);
        setGreen(green);
        setBlue(blue);
        setAlpha(alpha);
    }

    /// The alpha channel values for transparent and opaque
    enum {
        Transparent = SDL_ALPHA_TRANSPARENT,
        Opaque = SDL_ALPHA_OPAQUE
    };

    /// Compares colors (without alpha channel !)
    bool equals(const SDLColor &other) const {
        return sdl_color.r == other.sdl_color.r &&
               sdl_color.g == other.sdl_color.g &&
               sdl_color.b == other.sdl_color.b;
    }

    bool operator==(const SDLColor &other) const {
        return (memcmp(&sdl_color, &other.sdl_color, sizeof(SDL_Color)) == 0);
    }

    /// Inequality comparison
    bool operator!=(const SDLColor &other) const {
        return !(*this == other);
    }

    static void calcBlendFactors(int factor, int& new_factor, int& old_factor) {
        // it won't work in previous SDL
        assert(Opaque);
        // transparent == 0
        new_factor = factor;
        old_factor = Opaque - new_factor;
    }

    static SDLColor blend(const SDLColor& old_color, int old_factor,
                          const SDLColor& new_color, int new_factor,
                          int new_alpha_factor = Transparent, int old_alpha_factor = Opaque) {

        return SDLColor((new_factor * new_color.red() + old_factor * old_color.red()) / 255,
                        (new_factor * new_color.green() + old_factor * old_color.green()) / 255,
                        (new_factor * new_color.blue() + old_factor * old_color.blue()) / 255,
                        (new_alpha_factor * new_color.alpha() + old_alpha_factor * old_color.alpha()) / 255);
    }

private:
    SDL_Color sdl_color;
};

} // namespace

#endif //WT_SDLCOLOR_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.