OSDLFixedFont.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_FIXED_FONT_H_
#define OSDL_FIXED_FONT_H_



#include "OSDLFont.h"         // for inheritance

#include "Ceylan.h"           // for Ceylan::Byte, Height

#include <string>





namespace OSDL
{



    namespace Video
    {



        // Fonts are rendered to surfaces.
        class Surface ;




        namespace TwoDimensional
        {
            
                        
            
            namespace Text
            {   
            
            

                extern OSDL_DLL const Length BasicFontCharacterWidth ;
                
                
                extern OSDL_DLL const Length BasicFontCharacterHeight ;
                
                
                
                OSDL_DLL bool printBasic( 
                    const std::string & text, 
                    Surface & targetSurface, Coordinate x, Coordinate y,
                    Pixels::ColorElement red, Pixels::ColorElement blue,
                    Pixels::ColorElement green, 
                    Pixels::ColorElement alpha = Pixels::AlphaOpaque ) ; 
                
                
                
                OSDL_DLL bool printBasic( 
                    const std::string & text, 
                    Surface & targetSurface,
                    Coordinate x, Coordinate y, 
                    Pixels::ColorDefinition colorDef ) ;
                    
                    


                class OSDL_DLL FixedFont: public Font
                {
                
                
                
                    public:
                        
                            
                                            
                        
                        FixedFont( 
                            Length characterWidth, 
                            Length characterHeight, 
                            RenderingStyle renderingStyle = Normal,
                            bool convertToDisplay = true,
                            RenderCache cacheSettings = GlyphCached,
                            AllowedCachePolicy cachePolicy
                                = DropLessRequestedFirst,
                            Ceylan::System::Size quota = 0 ) ;
                         
                         
                         
                        explicit FixedFont( 
                            const std::string & fontFilename, 
                            bool convertToDisplay = true,
                            RenderCache cacheSettings = GlyphCached,
                            AllowedCachePolicy cachePolicy 
                                = DropLessRequestedFirst,
                            Ceylan::System::Size quota = 0 ) ;
                        
                        
                        
                        virtual ~FixedFont() throw() ;
                                
                                                
                                     
                        virtual Width getWidth() const ;



                        virtual Width getWidth( Ceylan::Latin1Char character )
                            const ;



                        virtual SignedWidth getWidthOffset( 
                            Ceylan::Latin1Char character ) const ;



                        virtual SignedHeight getHeightAboveBaseline(
                            Ceylan::Latin1Char character ) const ;



                        virtual SignedLength getAdvance() const ;
                        
                        
                        
                        virtual SignedLength getAdvance( 
                            Ceylan::Latin1Char character ) const ;



                        virtual Width getInterGlyphWidth() const ;
                
                         
                         
                        virtual Text::Height getHeight() const ;
                                                 
                                                 
                         
                        virtual SignedHeight getAscent() const ;
                         
                         
                         
                        virtual SignedHeight getDescent() const ;
                         
                         
                         
                        virtual Text::Height getLineSkip() const ;
                        
                        
                        
                        
                        // Bounding boxes section.
                        
                        
                        
                        virtual UprightRectangle & getBoundingBox() const ;
                            
                         
                         
                        virtual UprightRectangle & getBoundingBoxFor( 
                            const std::string & word ) const ;
                             
                             
                             
                        
                        // Render section.
                             
                             
                             
                        virtual Surface & renderLatin1Glyph( 
                            Ceylan::Latin1Char character, 
                            RenderQuality quality = Solid,
                            Pixels::ColorDefinition glyphColor = Pixels::White
                        ) ;
                    
                    
                        
                        virtual void blitLatin1Glyph( 
                            Surface & targetSurface,
                            Coordinate x, Coordinate y, 
                            Ceylan::Latin1Char character, 
                            RenderQuality quality = Solid, 
                            Pixels::ColorDefinition glyphColor = Pixels::White 
                        ) ;
                        
                        
                        
                        virtual Surface & renderLatin1GlyphAlpha(
                            Ceylan::Latin1Char character, 
                            RenderQuality quality = Solid,
                            Pixels::ColorDefinition glyphColor = Pixels::White 
                        ) ;
                        
                        
                            
                        /*
                         * Rendering and blitting of whole texts are inherited
                         * from Font mother class.
                         *
                         */
                        
                            
                            
                        virtual const std::string toString( 
                                Ceylan::VerbosityLevels level = Ceylan::high ) 
                            const ;



                        
                        // Static section.
    
    
    
                        static RenderQuality GetObtainedQualityFor(
                            RenderQuality targetedQuality ) ;
                         
    
    
                        static void SetFontSettings( 
                            const Ceylan::Byte * fontData, 
                            Length characterWidth, 
                            Length characterHeight ) ;

                         
                         
                        static Ceylan::System::FileLocator 
                            FixedFontFileLocator ;



                        static std::string FontFileExtension ;
                        
                        
                        
                        static const Ceylan::Float32 SpaceWidthFactor ;
                        
                        
                        
                        
                    protected:
                            
                                                
                        
                        static const RenderQuality DefaultQuality = Solid ;
                        
                            
                            
                        virtual void loadFontFrom( 
                            const std::string & fontFilename ) ;
                        
                            
                        
                        virtual const Surface & submitLatin1GlyphToCache( 
                            Ceylan::Latin1Char character,
                            Pixels::ColorDefinition glyphColor ) ;
                            
                            
                        
                        virtual Surface & basicRenderLatin1Glyph(
                            Ceylan::Latin1Char character,
                            Pixels::ColorDefinition glyphColor ) ;
                            
                            
                            
                        virtual void basicBlitLatin1Glyph( 
                            Surface & targetSurface, 
                            Coordinate x, Coordinate y, 
                            Ceylan::Latin1Char character,
                            Pixels::ColorDefinition glyphColor ) ;
                        
                        
                        
                                                        
                        Length _width ;
                        
                        
                        
                        Length _height ;
                            
                                                
                            
                        char * _fontData ;
                        
                        
                                                                        
                        static std::string BuildFontFilenameFor( 
                            Length characterWidth, 
                            Length characterHeight, 
                            RenderingStyle renderingStyle ) ;
                            
                            
                            
                        
                        // Static section.
                        
                        
                        
                        static void GetFontAttributesFrom( 
                            const std::string & filename, 
                            Length & characterWidth, 
                            Length & characterHeight, 
                            RenderingStyle & renderingStyle ) ;
                    
                    
                    
                        static const Ceylan::Uint16 FontCharacterCount ;
                    
                    
                    
                    
                    private:
                                
                        
                                    
                        FixedFont( const FixedFont & source ) ;
            
            
            
                        FixedFont & operator = ( const FixedFont & source ) ;
                
                                    
                
                } ;
                
                
            } 
            
        }   
            
    }
    
}       



#endif // OSDL_FIXED_FONT_H_

---