OSDLImage.h

Go to the documentation of this file.

#ifndef OSDL_IMAGE_H_
#define OSDL_IMAGE_H_


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

#include "Ceylan.h"


#include <string>



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 ) throw() ; 
                    virtual ~ImageException() throw() ; 
            } ;
                
                
                
            class OSDL_DLL Image : public Ceylan::TextDisplayable
            {
                
                
                public:
                    
                    
                    explicit Image( const std::string & filename ) 
                        throw( ImageException ) ;
                    
                                        
                    virtual ~Image() throw() ;
                    
                    
                    
                    // Static section.
                    
                    
                    static Surface & LoadIcon( const std::string & filename, 
                        Pixels::ColorElement ** mask ) throw( ImageException ) ;
                
                                
                            
                                        
                    // Load image section.          
                    
                                            
                    
                    static void Load( Surface & targetSurface, 
                            const std::string & filename,
                            bool blitOnly = false,
                            bool convertToDisplay = true,
                            bool convertWithAlpha = true  ) 
                        throw( ImageException ) ;   
                    
                        
                        
                    static void LoadJPG( Surface & targetSurface, 
                            const std::string & filename,
                            bool blitOnly = false,
                            bool convertToDisplay = true,
                            bool convertWithAlpha = true  ) 
                        throw( ImageException ) ;   



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



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



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



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



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



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



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



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


                        
                    virtual const std::string toString( 
                            Ceylan::VerbosityLevels level = Ceylan::high ) 
                        const throw() ;
                    
                    
                        
                protected:
                
                
                    std::string _filename ;
                        
                        
                        
                private:
            
            
                    explicit Image( const Image & source ) throw() ;
            
            
                    Image & operator = ( const Image & source ) throw() ;
                
                
                    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 ;
        
                
            } ;
        }       
    }
}       


#endif // OSDL_IMAGE_H_

---