OSDLImage.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_IMAGE_H_
#define OSDL_IMAGE_H_


#include "OSDLPixel.h"           // for Pixels::ColorElement
#include "OSDLVideoTypes.h"      // for VideoException

#include "Ceylan.h"


#include <string>



// To protect LoadIcon:
#include "OSDLIncludeCorrecter.h"




namespace OSDL
{


    namespace Video
    {



        // Images are loaded into surfaces.
        class Surface ;



        namespace TwoDimensional
        {
            
            
            
            class OSDL_DLL ImageException : public OSDL::Video::VideoException 
            { 
                public: 
                
                    ImageException( const std::string & reason ) ; 
                    
                    virtual ~ImageException() throw() ; 
                    
            } ;
                
                
                
            // Forward-declaration for next counted pointer:
            class Image ;
        
        
            typedef Ceylan::CountedPointer<Image> ImageCountedPtr ;
            
            
            
                
            class OSDL_DLL Image : public Ceylan::TextDisplayable,
                public Ceylan::LoadableWithContent<Surface>
            {
                
                
                
                public:
                    
                    
                    
                    explicit Image( 
                        const std::string & imageFilename,
                        bool preload = true, 
                        bool convertToDisplayFormat = true,
                        bool convertWithAlpha = true ) ;
                    
                    
                                        
                    virtual ~Image() throw() ;
                    
                    
                    
                    
                    // LoadableWithContent template instanciation.
        
                
                
                    virtual bool load() ;
        
        
        
                    virtual bool unload() ;
                    
                    
                    
                    virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) const ;
    
                    
                    
                    
                    // Static section.
                    
                    
                    
                    static Surface & LoadIcon( const std::string & filename, 
                        Pixels::ColorElement ** mask ) ;
                
                                
                            
                            
                                        
                    // Load image section.          
                    
                                            
                    
                    static void Load( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    
                    
                        
                        
                    static void LoadJPG( 
                        Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadPNG( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadBMP( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadGIF( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadLBM( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadPCX( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadPNM( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadTGA( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;    



                    static void LoadXPM( Surface & targetSurface, 
                        const std::string & filename,
                        bool blitOnly = false,
                        bool convertToDisplay = true,
                        bool convertWithAlpha = true ) ;  
                    
                    
                    
                    
                    
                    // Save image section.          
                    
                    
                                            
                    static void SavePNG( Surface & targetSurface, 
                        const std::string & filename, 
                        bool overwrite = true ) ;   
                        
                                        
                                            
                    static void SaveBMP( Surface & targetSurface, 
                        const std::string & filename,
                        bool overwrite = true ) ;   



                        
                protected:
                
                    
                    
                    /*
                     * The internal image surface itself is in the _content
                     * member, inherited from the loadable template.
                     *
                     */
                        
                        
                    bool _convertToDisplayFormat ;
                    
                    
                    
                    bool _convertWithAlpha ;
                    
                        
                    
                        
                private:
            
            
            
                    explicit Image( const Image & source ) ;
            
            
            
                    Image & operator = ( const Image & source ) ;
                
                
                
                
                
                    static const std::string JPGTag ;
                    
                    
                    
                    static const std::string PNGTag ;
        
        
        
                    static const std::string BMPTag ;
                    
                    
                    
                    static const std::string GIFTag ;
        
        
        
                    static const std::string LBMTag ;
        
        
        
                    static const std::string PCXTag ;
        
        
                    static const std::string PNMTag ;
        
        
        
                    static const std::string TGATag ;
        
        
        
                    static const std::string XPMTag ;
        
        
                
            } ;




            typedef struct 
            {
            
            
                Ceylan::Uint16 type ;
                
                
                Ceylan::Uint32 size ;
                
                
                Ceylan::Uint16 firstReserved ;


                Ceylan::Uint16 secondReserved ;
                    
                                
                Ceylan::Uint32 offset ;


            } 
            
#ifndef CEYLAN_RUNS_ON_WINDOWS
                /*
                 * g++ (gcc) needs this __attribute__, but Visual C++ does 
                 * not understand it.
                 *
                 * As we are here in a public header file, only the
                 * CEYLAN_RUNS_ON_WINDOWS configuration-specific preprocessor
                 * symbol is available here.
                 *
                 */
        __attribute__ ((packed))   

#endif // CEYLAN_RUNS_ON_WINDOWS
            
            BMPHeader ;
            
            
            
            typedef struct 
            {
            
            
                Ceylan::Uint32 size ;
                    
                    
                Ceylan::Uint32 width ;
                
                
                Ceylan::Uint32 height ;
                
                
                Ceylan::Uint16 planes ;
                
                
                Ceylan::Uint16 bits ;
                    
                        
                Ceylan::Uint32 compression ;


                Ceylan::Uint32 imagesize ;


                Ceylan::Uint32 xresolution ;


                Ceylan::Uint32 yresolution ;


                Ceylan::Uint32 ncolours ;


                Ceylan::Uint32 importantcolours ;


            }
            
#ifndef CEYLAN_RUNS_ON_WINDOWS
                /*
                 * g++ (gcc) needs this __attribute__, but Visual C++ does 
                 * not understand it.
                 *
                 * As we are here in a public header file, only the
                 * CEYLAN_RUNS_ON_WINDOWS configuration-specific preprocessor
                 * symbol is available here.
                 *
                 */
        __attribute__ ((packed))  

#endif // CEYLAN_RUNS_ON_WINDOWS
            
            BMPInfoHeader ;
            

        }
                
    }
    
}       



#endif // OSDL_IMAGE_H_

---