sprint/gtl/Font.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_FONT_H
#define _SPRINT_FONT_H

#include <sprint/gtl/BaseTypes.h>

namespace sprint {
        namespace gtl {

class CLogFont : public LOGFONT
{
public:
        CLogFont()
        {
                memset(this, 0, sizeof(LOGFONT));
        }

        CLogFont(const LOGFONT& lf)
        {
                Copy(lf);
        }

        CLogFont(HFONT hFont)
        {
                ::GetObject(hFont, sizeof(LOGFONT), (LOGFONT*)this);
        }

        HFONT CreateFontIndirect() const
        {
                return ::CreateFontIndirect(this);
        }

        void SetBold()
        {
                lfWeight = FW_BOLD;
        }

        bool IsBold() const
        {
                return (lfWeight >= FW_BOLD);
        }

        void MakeBolder(int iScale = 1)
        {
                lfWeight += FW_BOLD * iScale;
        }

        void MakeLarger(int iScale)
        {
                if(lfHeight > 0)
                        lfHeight += iScale;
                else
                        lfHeight -= iScale;
        }

        void SetHeight(LONG nPointSize, HDC hDC = NULL)
        {
                // For MM_TEXT mapping mode
                lfHeight = -::MulDiv(nPointSize, ::GetDeviceCaps(hDC, LOGPIXELSY), 72);
        }

        LONG GetHeight(HDC hDC = NULL) const
        {
                // For MM_TEXT mapping mode
                return ::MulDiv(-lfHeight, 72, ::GetDeviceCaps(hDC, LOGPIXELSY));
        }

        LONG GetDeciPointHeight(HDC hDC = NULL) const
        {
#ifndef _WIN32_WCE
                POINT ptOrg = { 0, 0 };
                ::DPtoLP(hDC, &ptOrg, 1);
                POINT pt = { 0, 0 };
                pt.y = abs(lfHeight) + ptOrg.y;
                ::LPtoDP(hDC,&pt,1);
                return ::MulDiv(pt.y, 720, ::GetDeviceCaps(hDC, LOGPIXELSY));   // 72 points/inch, 10 decipoints/point
#else // CE specific
                // DP and LP are always the same on CE
                return ::MulDiv(abs(lfHeight), 720, ::GetDeviceCaps(hDC, LOGPIXELSY));   // 72 points/inch, 10 decipoints/point
#endif // !_WIN32_WCE
        }

        void SetHeightFromDeciPoint(LONG nDeciPtHeight, HDC hDC = NULL)
        {
#ifndef _WIN32_WCE
                POINT pt = { 0, 0 };
                pt.y = ::MulDiv(::GetDeviceCaps(hDC, LOGPIXELSY), nDeciPtHeight, 720);   // 72 points/inch, 10 decipoints/point
                ::DPtoLP(hDC, &pt, 1);
                POINT ptOrg = { 0, 0 };
                ::DPtoLP(hDC, &ptOrg, 1);
                lfHeight = -abs(pt.y - ptOrg.y);
#else // CE specific
                // DP and LP are always the same on CE
                lfHeight = -abs(::MulDiv(::GetDeviceCaps(hDC, LOGPIXELSY), nDeciPtHeight, 720));   // 72 points/inch, 10 decipoints/point
#endif // !_WIN32_WCE
        }

        void Copy(const LOGFONT & LogFont)
        {
                memcpy(this, &LogFont, sizeof(LOGFONT));
        }

        CLogFont& operator =(const CLogFont& src)
        {
                Copy(src);
                return *this;
        }

        CLogFont& operator =(const LOGFONT& src)
        {
                Copy(src);
                return *this;
        }

        CLogFont& operator =(HFONT hFont)
        {
                ::GetObject(hFont, sizeof(LOGFONT), (LOGFONT*)this);
                return *this;
        }

        bool operator ==(const LOGFONT& logfont) const
        {
                return(logfont.lfHeight == lfHeight &&
                       logfont.lfWidth == lfWidth &&
                       logfont.lfEscapement == lfEscapement &&
                       logfont.lfOrientation == lfOrientation &&
                       logfont.lfWeight == lfWeight &&
                       logfont.lfItalic == lfItalic &&
                       logfont.lfUnderline == lfUnderline &&
                       logfont.lfStrikeOut == lfStrikeOut &&
                       logfont.lfCharSet == lfCharSet &&
                       logfont.lfOutPrecision == lfOutPrecision &&
                       logfont.lfClipPrecision == lfClipPrecision &&
                       logfont.lfQuality == lfQuality &&
                       logfont.lfPitchAndFamily == lfPitchAndFamily &&
                       lstrcmp(logfont.lfFaceName, lfFaceName) == 0);
        }
};

template <bool t_bManaged>
class CFontT
{
public:
// Data members
        HFONT m_hFont;

// Constructor/destructor/operators
        CFontT(HFONT hFont = NULL) : m_hFont(hFont)
        { }
        
        ~CFontT()
        {
                if(t_bManaged && m_hFont != NULL)
                        DeleteObject();
        }

        CFontT<t_bManaged>& operator =(HFONT hFont)
        {
                Attach(hFont);
                return *this;
        }
        
        inline bool IsNull() const { return (m_hFont == NULL); }

        void Attach(HFONT hFont)
        {
                if(t_bManaged && m_hFont != NULL && m_hFont != hFont)
                        ::DeleteObject(m_hFont);
                m_hFont = hFont;
        }

        HFONT Detach()
        {
                HFONT hFont = m_hFont;
                m_hFont = NULL;
                return hFont;
        }

        inline operator HFONT() const { return m_hFont; }


// Create methods
        inline HFONT CreateFontIndirect(const LOGFONT & LogFont)
        {
                m_hFont = ::CreateFontIndirect(&LogFont);
                return m_hFont;
        }

        CFontT(const LOGFONT & LogFont) : m_hFont(NULL)
        {
                CreateFontIndirect(LogFont);
        }

        inline HFONT CreateFont(int nHeight, int nWidth, int nEscapement,
                        int nOrientation, int nWeight, BYTE bItalic, BYTE bUnderline,
                        BYTE cStrikeOut, BYTE nCharSet, BYTE nOutPrecision,
                        BYTE nClipPrecision, BYTE nQuality, BYTE nPitchAndFamily,
                        LPCTSTR lpszFacename)
        {
                m_hFont = ::CreateFont(nHeight, nWidth, nEscapement,
                        nOrientation, nWeight, bItalic, bUnderline, cStrikeOut,
                        nCharSet, nOutPrecision, nClipPrecision, nQuality,
                        nPitchAndFamily, lpszFacename);
                return m_hFont;
        }

        inline HFONT CreateFont(int nPointSize, LPCTSTR lpszFaceName, bool bBold = false, bool bItalic = false)
        {
                LOGFONT logFont = { 0 };
                logFont.lfCharSet = DEFAULT_CHARSET;
                logFont.lfHeight = nPointSize;
                lstrcpyn(logFont.lfFaceName, lpszFaceName, sizeof(logFont.lfFaceName) / sizeof(TCHAR));

                if(bBold)
                        logFont.lfWeight = FW_BOLD;
                if(bItalic)
                        logFont.lfItalic = (BYTE)TRUE;
                        
                return CreateFontIndirect(logFont);
        }

        HFONT CreatePointFont(int nPointSize, LPCTSTR lpszFaceName, HDC hDC = NULL, bool bBold = false, bool bItalic = false)
        {
                LOGFONT logFont = { 0 };
                logFont.lfCharSet = DEFAULT_CHARSET;
                logFont.lfHeight = nPointSize;
                lstrcpyn(logFont.lfFaceName, lpszFaceName, sizeof(logFont.lfFaceName) / sizeof(TCHAR));

                if(bBold)
                        logFont.lfWeight = FW_BOLD;
                if(bItalic)
                        logFont.lfItalic = (BYTE)TRUE;

                return CreatePointFontIndirect(logFont, hDC);
        }

        HFONT CreatePointFontIndirect(const LOGFONT & LogFont, HDC hDC = NULL)
        {
                HDC hDC1 = (hDC != NULL) ? hDC : ::GetDC(NULL);

                // convert nPointSize to logical units based on hDC
                LOGFONT logFont = LogFont;
#ifndef _WIN32_WCE
                POINT pt = { 0, 0 };
                pt.y = ::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), logFont.lfHeight, 720);   // 72 points/inch, 10 decipoints/point
                ::DPtoLP(hDC1, &pt, 1);
                POINT ptOrg = { 0, 0 };
                ::DPtoLP(hDC1, &ptOrg, 1);
                logFont.lfHeight = -abs(pt.y - ptOrg.y);
#else // CE specific
                // DP and LP are always the same on CE
                logFont.lfHeight = -abs(::MulDiv(::GetDeviceCaps(hDC1, LOGPIXELSY), logFont.lfHeight, 720));   // 72 points/inch, 10 decipoints/point
#endif // !_WIN32_WCE

                if(hDC == NULL)
                        ::ReleaseDC(NULL, hDC1);

                return CreateFontIndirect(logFont);
        }

        BOOL DeleteObject()
        {
                BOOL bRet = ::DeleteObject(m_hFont);
                if(bRet)
                        m_hFont = NULL;
                return bRet;
        }

// Attributes
        int GetLogFont(LOGFONT* pLogFont) const
        {
                return ::GetObject(m_hFont, sizeof(LOGFONT), pLogFont);
        }

        bool GetLogFont(LOGFONT& LogFont) const
        {
                return (::GetObject(m_hFont, sizeof(LOGFONT), &LogFont) == sizeof(LOGFONT));
        }
};

typedef CFontT<false>   CFontHandle;
typedef CFontT<true>    CFont;

} // gtl

} // sprint

#endif