OSDLPalette.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The OSDL 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 and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_PALETTE_H_
#define OSDL_PALETTE_H_

        
#include "OSDLPixel.h"       // for ColorDefinition, GammaFactor

#include "Ceylan.h"          // for TextDisplayable, Uint32, etc.




#if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 

// No need to include SDL header here:
struct SDL_Palette ;

#endif //  ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 




#include <string>




namespace OSDL
{


    
    namespace Video
    {
    


        typedef Ceylan::Uint16 ColorCount ;
        


        typedef Ceylan::Uint8 ColorIndex ;
        
        
        
        typedef Ceylan::SignedLongInteger ColorDistance ;
        
        
        
        typedef Ceylan::Uint16 PaletteIdentifier ;
        
        
        
        
#if ! defined(OSDL_USES_SDL) || OSDL_USES_SDL 

        typedef ::SDL_Palette LowLevelPalette ;
        
#else // OSDL_USES_SDL  

        struct LowLevelPalette
        {
        
            // Number of color defined.
            ColorCount ncolors ;
            
            // Array definitions.
            Pixels::ColorDefinition *colors ;
            
        } ;

#endif // OSDL_USES_SDL
        
        
        
        
        
        class OSDL_DLL PaletteException: public VideoException
        {
        
            public:
                explicit PaletteException( const std::string & message ) ;
                
                virtual ~PaletteException() throw() ;
                            
        } ;
        
    
    
    
        class OSDL_DLL Palette: public Ceylan::TextDisplayable
        {
        
            public:
            
            
            
                static const Ceylan::Flags Logical ;
                
                                
                static const Ceylan::Flags Physical ;
            
            
            
                explicit Palette( ColorCount numberOfColors, 
                    Pixels::ColorDefinition * colors = 0,
                    Pixels::PixelFormat * format = 0 ) ;

                
                
                explicit Palette( const std::string & paletteFilename ) ;
                    
                    
                    
                explicit Palette( const LowLevelPalette & palette ) ;
                
                
                
                virtual ~Palette() throw() ;
            
            
            
                virtual void load( ColorCount numberOfColors, 
                    Pixels::ColorDefinition * colors ) ;
            
            
            
                virtual ColorCount getNumberOfColors() const ;
                
                
                
                virtual const Pixels::PixelColor & getPixelColorAt( 
                    ColorCount index ) const ;
                    
                    
                    
                virtual Pixels::PixelColor * getPixelColors() const ;
                
                
                
                virtual const Pixels::ColorDefinition & getColorDefinitionAt(
                    ColorCount index ) const ;
                
                    
                    
                virtual void setColorDefinitionAt(
                    ColorCount targetIndex, 
                    const Pixels::ColorDefinition & newColorDefinition ) ;
                    
                    
                    
                virtual void setColorDefinitionAt(
                    ColorCount targetIndex, 
                    Pixels::ColorElement red,
                    Pixels::ColorElement green,
                    Pixels::ColorElement blue,
                    Pixels::ColorElement alpha = Pixels::AlphaOpaque ) ;
                    
                    
                    
                virtual Pixels::ColorDefinition * getColorDefinitions() const ;


                
                virtual bool hasColorKey() const ;
                
                
                
                virtual ColorCount getColorKeyIndex() const ;
                
                
                
                virtual void setColorKeyIndex( ColorCount colorkeyIndex ) ;
                
                    
                    
                virtual void updatePixelColorsFrom( 
                    const Pixels::PixelFormat & format ) ;



                virtual void quantize( 
                    Pixels::ColorElement quantizeMaxCoordinate,
                    bool scaleUp = false ) ;



                virtual void correctGamma( Pixels::GammaFactor gamma ) ;



                virtual ColorCount getClosestColorIndexTo(
                    const Pixels::ColorDefinition & color ) const ;
                    
                    

                virtual bool draw( Surface & targetSurface, 
                    const Pixels::ColorDefinition & backgroundColor 
                        = Pixels::White ) ;
                
                
                
                virtual bool hasDuplicates( bool useAlpha = false ) const ;
                
                
                
                virtual void save( const std::string & filename,
                    bool encoded = false ) const ;
                    
                    
                    
                virtual const std::string toString( 
                    Ceylan::VerbosityLevels level = Ceylan::high ) const ;




                
                // Static section.
                    
                        
                        
                static Palette & CreateGreyScalePalette( 
                    ColorCount numberOfColors = 256 ) ; 
            
            
            
                static Palette & CreateGradationPalette( 
                    const Pixels::ColorDefinition & colorStart,
                    const Pixels::ColorDefinition & colorEnd, 
                    ColorCount numberOfColors = 256 ) ; 
            
            
            
                static Palette & CreateMasterPalette( 
                    bool addColorkey = true ) ; 
            
            
            
            
            protected:
                
                
                
                virtual void invalidatePixelColors() ;
                
                
                     
                
                // Static section.
                
                
                
                static Pixels::ColorElement QuantizeComponent( 
                    Pixels::ColorElement component, 
                    Pixels::ColorElement newMaxCoordinate = 31 ) ;
                    
                    
                    
                static Pixels::ColorElement CorrectGammaComponent( 
                    Pixels::ColorElement component, 
                    Pixels::GammaFactor gamma ) ;
                    
                
                
                static ColorDistance GetDistance( 
                    const Pixels::ColorDefinition & firstColor,
                    const Pixels::ColorDefinition & secondColor ) ;
                                
                                        
            
                ColorCount _numberOfColors ;
                
                
                
                Pixels::ColorDefinition * _colorDefs ;
            
            
            
                Pixels::PixelColor * _pixelColors ;



                bool _converted ;
                
                

                bool _ownsColorDefinition ;
                
                    
                    
                            
            private:
            
            
                    
                bool _hasColorkey ;
                
                
                
                ColorCount _colorKeyIndex ;

        
        
                explicit Palette( const Palette & source ) ;
            
            
            
                Palette & operator = ( const Palette & source ) ;
        
        
        } ;
        
    
    }

}



#endif // OSDL_PALETTE_H_

---