X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0e320a79f187558effb04d92020b470372bbe456..7d0180d415f3cce126abebed2ef1d0fde00bcc61:/src/os2/font.cpp diff --git a/src/os2/font.cpp b/src/os2/font.cpp index 493a6a25ba..c1839db1ca 100644 --- a/src/os2/font.cpp +++ b/src/os2/font.cpp @@ -1,244 +1,1123 @@ ///////////////////////////////////////////////////////////////////////////// // Name: font.cpp // Purpose: wxFont class -// Author: AUTHOR +// Author: David Webster // Modified by: -// Created: ??/??/98 +// Created: 10/06/99 // RCS-ID: $Id$ -// Copyright: (c) AUTHOR -// Licence: wxWindows licence +// Copyright: (c) David Webster +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "font.h" -#endif +// ============================================================================ +// declarations +// ============================================================================ -#include "wx/defs.h" -#include "wx/string.h" -#include "wx/font.h" -#include "wx/gdicmn.h" +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + + #include +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifndef WX_PRECOMP + #include + #include "wx/setup.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/app.h" + #include "wx/font.h" +#endif // WX_PRECOMP + +#include "wx/os2/private.h" + +#include "wx/fontutil.h" +#include "wx/fontmap.h" + +#include "wx/tokenzr.h" -#if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) -#endif - -wxFontRefData::wxFontRefData() -{ - m_style = 0; - m_pointSize = 0; - m_family = 0; - m_style = 0; - m_weight = 0; - m_underlined = 0; - m_faceName = ""; -/* TODO - m_hFont = 0; -*/ -} -wxFontRefData::wxFontRefData(const wxFontRefData& data) -{ - m_style = data.m_style; - m_pointSize = data.m_pointSize; - m_family = data.m_family; - m_style = data.m_style; - m_weight = data.m_weight; - m_underlined = data.m_underlined; - m_faceName = data.m_faceName; -/* TODO - m_hFont = 0; -*/ +// ---------------------------------------------------------------------------- +// wxFontRefData - the internal description of the font +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT wxFontRefData: public wxGDIRefData +{ +public: + wxFontRefData() + { + Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, FALSE, + "", wxFONTENCODING_DEFAULT); + } + + wxFontRefData( int nSize + ,int nFamily + ,int nStyle + ,int nWeight + ,bool bUnderlined + ,const wxString& sFaceName + ,wxFontEncoding vEncoding + ) + { + Init( nSize + ,nFamily + ,nStyle + ,nWeight + ,bUnderlined + ,sFaceName + ,vEncoding + ); + } + + wxFontRefData( const wxNativeFontInfo& rInfo + ,WXHFONT hFont = 0 + ,WXHANDLE hPS = 0 + ) + { + Init( rInfo + ,hFont + ,hPS + ); + } + + wxFontRefData(const wxFontRefData& rData) + { + Init( rData.m_nPointSize + ,rData.m_nFamily + ,rData.m_nStyle + ,rData.m_nWeight + ,rData.m_bUnderlined + ,rData.m_sFaceName + ,rData.m_vEncoding + ); + m_nFontId = rData.m_nFontId; + } + + virtual ~wxFontRefData(); + + // + // Operations + // + bool Alloc(wxFont* pFont); + void Free(void); + + // + // All wxFont accessors + // + inline int GetPointSize(void) const + { + // + // We don't use the actual native font point size since it is + // the chosen physical font, which is usually only and approximation + // of the desired outline font. The actual displayable point size + // is the one stored in the refData + // + return m_nPointSize; + } + + inline int GetFamily(void) const + { + return m_nFamily; + } + + inline int GetStyle(void) const + { + return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetStyle() + : m_nStyle; + } + + inline int GetWeight(void) const + { + return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetWeight() + : m_nWeight; + } + + inline bool GetUnderlined(void) const + { + return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetUnderlined() + : m_bUnderlined; + } + + inline wxString GetFaceName(void) const + { + wxString sFaceName; + + if (m_bNativeFontInfoOk) + sFaceName = m_vNativeFontInfo.GetFaceName(); + else + sFaceName = m_sFaceName; + + return sFaceName; + } + + inline wxFontEncoding GetEncoding(void) const + { + return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetEncoding() + : m_vEncoding; + } + + inline WXHFONT GetHFONT(void) const { return m_hFont; } + inline HPS GetPS(void) const { return m_hPS; } + inline PFONTMETRICS GetFM(void) const { return m_pFM; } + inline int GetNumFonts(void) const { return m_nNumFonts; } + + // ... and setters + inline void SetPointSize(int nPointSize) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetPointSize(nPointSize); + else + m_nPointSize = nPointSize; + } + + inline void SetFamily(int nFamily) + { + m_nFamily = nFamily; + } + + inline void SetStyle(int nStyle) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetStyle((wxFontStyle)nStyle); + else + m_nStyle = nStyle; + } + + inline void SetWeight(int nWeight) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetWeight((wxFontWeight)nWeight); + else + m_nWeight = nWeight; + } + + inline void SetFaceName(const wxString& sFaceName) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetFaceName(sFaceName); + else + m_sFaceName = sFaceName; + } + + inline void SetUnderlined(bool bUnderlined) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetUnderlined(bUnderlined); + else + m_bUnderlined = bUnderlined; + } + + inline void SetEncoding(wxFontEncoding vEncoding) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetEncoding(vEncoding); + else + m_vEncoding = vEncoding; + } + + inline void SetPS(HPS hPS) + { + m_hPS = hPS; + } + + inline void SetFM(PFONTMETRICS pFM) + { + m_pFM = pFM; + } + + inline void SetNumFonts(int nNumFonts) + { + m_nNumFonts = nNumFonts; + } + + // + // Native font info tests + // + bool HasNativeFontInfo() const { return m_bNativeFontInfoOk; } + + const wxNativeFontInfo& GetNativeFontInfo() const + { return m_vNativeFontInfo; } + +protected: + // + // Common part of all ctors + // + void Init( int nSize + ,int nFamily + ,int nStyle + ,int nWeight + ,bool bUnderlined + ,const wxString& rsFaceName + ,wxFontEncoding vEncoding + ); + + void Init( const wxNativeFontInfo& rInfo + ,WXHFONT hFont = 0 + ,WXHANDLE hPS = 0 + ); + // + // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE + // DELETED by destructor + // + bool m_bTemporary; + int m_nFontId; + + // + // Font characterstics + // + int m_nPointSize; + int m_nFamily; + int m_nStyle; + int m_nWeight; + bool m_bUnderlined; + wxString m_sFaceName; + wxFontEncoding m_vEncoding; + WXHFONT m_hFont; + + // + // Native font info + // + wxNativeFontInfo m_vNativeFontInfo; + bool m_bNativeFontInfoOk; + + // + // Some PM specific stuff + // + PFONTMETRICS m_pFM; // array of FONTMETRICS structs + int m_nNumFonts; // number of fonts in array + HPS m_hPS; // PS handle this font belongs to + FATTRS m_vFattrs; // Current fattrs struct + FACENAMEDESC m_vFname; // Current facename struct + bool m_bInternalPS; // Internally generated PS? +}; // end of CLASS wxFontRefData + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +void wxFontRefData::Init( + int nPointSize +, int nFamily +, int nStyle +, int nWeight +, bool bUnderlined +, const wxString& rsFaceName +, wxFontEncoding vEncoding +) +{ + m_nStyle = nStyle; + m_nPointSize = nPointSize; + m_nFamily = nFamily; + m_nStyle = nStyle; + m_nWeight = nWeight; + m_bUnderlined = bUnderlined; + m_sFaceName = rsFaceName; + m_vEncoding = vEncoding; + m_hFont = 0; + + m_bNativeFontInfoOk = FALSE; + + m_nFontId = 0; + m_bTemporary = FALSE; + m_pFM = (PFONTMETRICS)NULL; + m_hPS = NULLHANDLE; + m_nNumFonts = 0; +} // end of wxFontRefData::Init + +void wxFontRefData::Init( + const wxNativeFontInfo& rInfo +, WXHFONT hFont //this is the FontId -- functions as the hFont for OS/2 +, WXHANDLE hPS // Presentation Space we are using +) +{ + // + // hFont may be zero, or it be passed in case we really want to + // use the exact font created in the underlying system + // (for example where we can't guarantee conversion from HFONT + // to LOGFONT back to HFONT) + // + m_hFont = hFont; + m_nFontId = (int)hFont; + + m_bNativeFontInfoOk = TRUE; + m_vNativeFontInfo = rInfo; + + if (m_hPS == NULLHANDLE) + { + m_hPS = ::WinGetPS(HWND_DESKTOP); + m_bInternalPS; + } + else + m_hPS = (HPS)hPS; } wxFontRefData::~wxFontRefData() { - // TODO: delete font data + Free(); } -wxFont::wxFont() +bool wxFontRefData::Alloc( + wxFont* pFont +) { - if ( wxTheFontList ) - wxTheFontList->Append(this); -} + wxString sFaceName; + long flId = m_hFont; + long lRc; + short nIndex = 0; + PFONTMETRICS pFM = NULL; + + if (!m_bNativeFontInfoOk) + { + wxFillLogFont( &m_vNativeFontInfo.fa + ,&m_vNativeFontInfo.fn + ,&m_hPS + ,&m_bInternalPS + ,&flId + ,sFaceName + ,pFont + ); + m_bNativeFontInfoOk = TRUE; + } + + if((lRc = ::GpiCreateLogFont( m_hPS + ,NULL + ,flId + ,&m_vNativeFontInfo.fa + )) != GPI_ERROR) + { + m_hFont = (WXHFONT)flId; + m_nFontId = flId; + } + if (!m_hFont) + { + wxLogLastError("CreateFont"); + } + + ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space + ::GpiQueryFontMetrics(m_hPS, sizeof(FONTMETRICS), &m_vNativeFontInfo.fm); + + // + // Set refData members with the results + // + memcpy(&m_vFattrs, &m_vNativeFontInfo.fa, sizeof(m_vFattrs)); + memcpy(&m_vFname, &m_vNativeFontInfo.fn, sizeof(m_vFname)); + // + // Going to leave the point size alone. Mostly we use outline fonts + // that can be set to any point size inside of Presentation Parameters, + // regardless of whether or not the actual font is registered in the system. + // The GpiCreateLogFont will do enough by selecting the right family, + // and face name. + // + if (strcmp(m_vNativeFontInfo.fa.szFacename, "Times New Roman") == 0) + m_nFamily = wxROMAN; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Tms Rmn") == 0) + m_nFamily = wxSWISS; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "WarpSans") == 0) + m_nFamily = wxSWISS; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Helvitica") == 0) + m_nFamily = wxSWISS; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Helv") == 0) + m_nFamily = wxSWISS; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Script") == 0) + m_nFamily = wxSCRIPT; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Courier New") == 0) + m_nFamily = wxTELETYPE; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "Courier") == 0) + m_nFamily = wxTELETYPE; + else if (strcmp(m_vNativeFontInfo.fa.szFacename, "System VIO") == 0) + m_nFamily = wxMODERN; + else + m_nFamily = wxSWISS; + + if (m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_ITALIC) + m_nStyle = wxFONTSTYLE_ITALIC; + else + m_nStyle = wxFONTSTYLE_NORMAL; + switch(m_vNativeFontInfo.fn.usWeightClass) + { + case FWEIGHT_DONT_CARE: + m_nWeight = wxFONTWEIGHT_NORMAL; + break; + + case FWEIGHT_NORMAL: + m_nWeight = wxFONTWEIGHT_NORMAL; + break; + + case FWEIGHT_LIGHT: + m_nWeight = wxFONTWEIGHT_LIGHT; + break; -wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) + case FWEIGHT_BOLD: + m_nWeight = wxFONTWEIGHT_BOLD; + break; + + case FWEIGHT_ULTRA_BOLD: + m_nWeight = wxFONTWEIGHT_MAX; + break; + + default: + m_nWeight = wxFONTWEIGHT_NORMAL; + } + m_bUnderlined = ((m_vNativeFontInfo.fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0); + m_sFaceName = m_vNativeFontInfo.fa.szFacename; + m_vEncoding = wxGetFontEncFromCharSet(m_vNativeFontInfo.fa.usCodePage); + + // + // We don't actuall keep the font around if using a temporary PS + // + if (m_bInternalPS) + { + if(m_hFont) + ::GpiDeleteSetId( m_hPS + ,flId + ); + + ::WinReleasePS(m_hPS); + } + else + // + // Select the font into the Presentation space + // + ::GpiSetCharSet(m_hPS, flId); // sets font for presentation space + return TRUE; +} // end of wxFontRefData::Alloc + +void wxFontRefData::Free() { - Create(pointSize, family, style, weight, underlined, faceName); + if (m_pFM) + delete [] m_pFM; + m_pFM = (PFONTMETRICS)NULL; - if ( wxTheFontList ) - wxTheFontList->Append(this); -} + if ( m_hFont ) + { + if (!::GpiSetCharSet(m_hPS, LCID_DEFAULT)) + { + wxLogLastError(wxT("DeleteObject(font)")); + } + ::GpiDeleteSetId(m_hPS, 1L); /* delete the logical font */ + m_nFontId = 0; + m_hFont = 0; + } + if (m_bInternalPS) + ::WinReleasePS(m_hPS); + m_hPS = NULLHANDLE; +} // end of wxFontRefData::Free + +// ---------------------------------------------------------------------------- +// wxNativeFontInfo +// ---------------------------------------------------------------------------- -bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) +void wxNativeFontInfo::Init() { - UnRef(); - m_refData = new wxFontRefData; + memset(&fa, '\0', sizeof(FATTRS)); +} // end of wxNativeFontInfo::Init + +int wxNativeFontInfo::GetPointSize() const +{ + return fm.lEmHeight; +} // end of wxNativeFontInfo::GetPointSize + +wxFontStyle wxNativeFontInfo::GetStyle() const +{ + return fa.fsSelection & FATTR_SEL_ITALIC ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; +} // end of wxNativeFontInfo::GetStyle + +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + switch(fn.usWeightClass) + { + case FWEIGHT_DONT_CARE: + return wxFONTWEIGHT_NORMAL; - M_FONTDATA->m_family = family; - M_FONTDATA->m_style = style; - M_FONTDATA->m_weight = weight; - M_FONTDATA->m_pointSize = pointSize; - M_FONTDATA->m_underlined = underlined; - M_FONTDATA->m_faceName = faceName; + case FWEIGHT_NORMAL: + return wxFONTWEIGHT_NORMAL; + case FWEIGHT_LIGHT: + return wxFONTWEIGHT_LIGHT; + + case FWEIGHT_BOLD: + return wxFONTWEIGHT_BOLD; + + case FWEIGHT_ULTRA_BOLD: + return wxFONTWEIGHT_MAX; + } + return wxFONTWEIGHT_NORMAL; +} // end of wxNativeFontInfo::GetWeight + +bool wxNativeFontInfo::GetUnderlined() const +{ + return ((fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0); +} // end of wxNativeFontInfo::GetUnderlined + +wxString wxNativeFontInfo::GetFaceName() const +{ + return fm.szFacename; +} // end of wxNativeFontInfo::GetFaceName + +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + int nFamily; + + // + // Extract family from facename + // + if (strcmp(fa.szFacename, "Times New Roman") == 0) + nFamily = wxROMAN; + else if (strcmp(fa.szFacename, "WarpSans") == 0) + nFamily = wxSWISS; + else if (strcmp(fa.szFacename, "Script") == 0) + nFamily = wxSCRIPT; + else if (strcmp(fa.szFacename, "Courier New") == 0) + nFamily = wxMODERN; + else + nFamily = wxSWISS; + return (wxFontFamily)nFamily; +} // end of wxNativeFontInfo::GetFamily + +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxGetFontEncFromCharSet(fa.usCodePage); +} // end of wxNativeFontInfo::GetEncoding + +void wxNativeFontInfo::SetPointSize( + int nPointsize +) +{ + fm.lEmHeight = (LONG)nPointsize; +} // end of wxNativeFontInfo::SetPointSize + +void wxNativeFontInfo::SetStyle( + wxFontStyle eStyle +) +{ + switch (eStyle) + { + default: + wxFAIL_MSG( _T("unknown font style") ); + // fall through + + case wxFONTSTYLE_NORMAL: + break; + + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + fa.fsSelection |= FATTR_SEL_ITALIC; + break; + } +} // end of wxNativeFontInfo::SetStyle + +void wxNativeFontInfo::SetWeight( + wxFontWeight eWeight +) +{ + switch (eWeight) + { + default: + wxFAIL_MSG( _T("unknown font weight") ); + // fall through + + case wxFONTWEIGHT_NORMAL: + fn.usWeightClass = FWEIGHT_NORMAL; + break; + + case wxFONTWEIGHT_LIGHT: + fn.usWeightClass = FWEIGHT_LIGHT; + break; + + case wxFONTWEIGHT_BOLD: + fn.usWeightClass = FWEIGHT_BOLD; + break; + } +} // end of wxNativeFontInfo::SetWeight + +void wxNativeFontInfo::SetUnderlined( + bool bUnderlined +) +{ + if(bUnderlined) + fa.fsSelection |= FATTR_SEL_UNDERSCORE; +} // end of wxNativeFontInfo::SetUnderlined + +void wxNativeFontInfo::SetFaceName( + wxString sFacename +) +{ + wxStrncpy(fa.szFacename, sFacename, WXSIZEOF(fa.szFacename)); +} // end of wxNativeFontInfo::SetFaceName + +void wxNativeFontInfo::SetFamily( + wxFontFamily eFamily +) +{ + wxString sFacename; + + switch (eFamily) + { + case wxSCRIPT: + sFacename = _T("Script"); + break; + + case wxDECORATIVE: + sFacename = _T("Times New Roman"); + break; + + case wxROMAN: + sFacename = _T("Times New Roman"); + break; + + case wxTELETYPE: + case wxMODERN: + sFacename = _T("Courier New"); + break; + + case wxSWISS: + sFacename = _T("WarpSans"); + break; + + case wxDEFAULT: + default: + sFacename = _T("Helv"); + } + + if (!wxStrlen(fa.szFacename) ) + { + SetFaceName(sFacename); + } +} // end of wxNativeFontInfo::SetFamily + +void wxNativeFontInfo::SetEncoding( + wxFontEncoding eEncoding +) +{ + wxNativeEncodingInfo vInfo; + + if ( !wxGetNativeFontEncoding( eEncoding + ,&vInfo + )) + { +#if wxUSE_FONTMAP + if (wxTheFontMapper->GetAltForEncoding( eEncoding + ,&vInfo + )) + { + if (!vInfo.facename.empty()) + { + // + // If we have this encoding only in some particular facename, use + // the facename - it is better to show the correct characters in a + // wrong facename than unreadable text in a correct one + // + SetFaceName(vInfo.facename); + } + } + else +#endif // wxUSE_FONTMAP + { + // unsupported encoding, replace with the default + vInfo.charset = 850; + } + } + fa.usCodePage = vInfo.charset; +} // end of wxNativeFontInfo::SetFaceName + +bool wxNativeFontInfo::FromString( + const wxString& rsStr +) +{ + long lVal; + + wxStringTokenizer vTokenizer(rsStr, _T(";")); + + // + // First the version + // + wxString sToken = vTokenizer.GetNextToken(); + + if (sToken != _T('0')) + return FALSE; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fm.lEmHeight = lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.lAveCharWidth = lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.fsSelection = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.fsType = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.fsFontUse = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.idRegistry = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.usCodePage = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fa.lMatch = lVal; + + sToken = vTokenizer.GetNextToken(); + if (!sToken.ToLong(&lVal)) + return FALSE; + fn.usWeightClass = (USHORT)lVal; + + sToken = vTokenizer.GetNextToken(); + if(!sToken) + return FALSE; + wxStrcpy(fa.szFacename, sToken.c_str()); + return TRUE; +} // end of wxNativeFontInfo::FromString + +wxString wxNativeFontInfo::ToString() const +{ + wxString sStr; + + sStr.Printf(_T("%d;%ld;%ld;%ld;%d;%d;%d;%d;%d;%ld;%d;%s"), + 0, // version, in case we want to change the format later + fm.lEmHeight, + fa.lAveCharWidth, + fa.lMaxBaselineExt, + fa.fsSelection, + fa.fsType, + fa.fsFontUse, + fa.idRegistry, + fa.usCodePage, + fa.lMatch, + fn.usWeightClass, + fa.szFacename); + return sStr; +} // end of wxNativeFontInfo::ToString + +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- + +void wxFont::Init() +{ +} // end of wxFont::Init + +bool wxFont::Create( + const wxNativeFontInfo& rInfo +, WXHFONT hFont +) +{ + UnRef(); + m_refData = new wxFontRefData( rInfo + ,hFont + ); RealizeResource(); + return TRUE; +} // end of wxFont::Create +wxFont::wxFont( + const wxString& rsFontdesc +) +{ + wxNativeFontInfo vInfo; + + if (vInfo.FromString(rsFontdesc)) + (void)Create(vInfo); +} // end of wxFont::wxFont + +// ---------------------------------------------------------------------------- +// Constructor for a font. Note that the real construction is done +// in wxDC::SetFont, when information is available about scaling etc. +// ---------------------------------------------------------------------------- +bool wxFont::Create( + int nPointSize +, int nFamily +, int nStyle +, int nWeight +, bool bUnderlined +, const wxString& rsFaceName +, wxFontEncoding vEncoding +) +{ + UnRef(); + + // + // wxDEFAULT is a valid value for the font size too so we must treat it + // specially here (otherwise the size would be 70 == wxDEFAULT value) + // + if (nPointSize == wxDEFAULT) + { + nPointSize = wxNORMAL_FONT->GetPointSize(); + } + m_refData = new wxFontRefData( nPointSize + ,nFamily + ,nStyle + ,nWeight + ,bUnderlined + ,rsFaceName + ,vEncoding + ); + RealizeResource(); return TRUE; -} +} // end of wxFont::Create wxFont::~wxFont() { - if (wxTheFontList) - wxTheFontList->DeleteObject(this); -} +} // end of wxFont::~wxFont + +// ---------------------------------------------------------------------------- +// real implementation +// Boris' Kovalenko comments: +// Because OS/2 fonts are associated with PS we can not create the font +// here, but we may check that font definition is true +// ---------------------------------------------------------------------------- bool wxFont::RealizeResource() { - // TODO: create the font (if there is a native font object) + if ( GetResourceHandle() ) + { + return TRUE; + } + return M_FONTDATA->Alloc(this); +} // end of wxFont::RealizeResource + +bool wxFont::FreeResource( + bool bForce +) +{ + if (GetResourceHandle()) + { + M_FONTDATA->Free(); + return TRUE; + } return FALSE; -} +} // end of wxFont::FreeResource + +WXHANDLE wxFont::GetResourceHandle() +{ + return GetHFONT(); +} // end of wxFont::GetResourceHandle + +WXHFONT wxFont::GetHFONT() const +{ + return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0; +} // end of wxFont::GetHFONT + +bool wxFont::IsFree() const +{ + return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0); +} // end of wxFont::IsFree void wxFont::Unshare() { - // Don't change shared data - if (!m_refData) + // Don't change shared data + if ( !m_refData ) { - m_refData = new wxFontRefData(); - } + m_refData = new wxFontRefData(); + } else { - wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); - UnRef(); - m_refData = ref; - } -} + wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); + UnRef(); + m_refData = ref; + } +} // end of wxFont::Unshare + +// ---------------------------------------------------------------------------- +// change font attribute: we recreate font when doing it +// ---------------------------------------------------------------------------- -void wxFont::SetPointSize(int pointSize) +void wxFont::SetPointSize( + int nPointSize +) { Unshare(); - M_FONTDATA->m_pointSize = pointSize; + M_FONTDATA->SetPointSize(nPointSize); RealizeResource(); -} +} // end of wxFont::SetPointSize -void wxFont::SetFamily(int family) +void wxFont::SetFamily( + int nFamily +) { Unshare(); - M_FONTDATA->m_family = family; + M_FONTDATA->SetFamily(nFamily); RealizeResource(); -} +} // end of wxFont::SetFamily -void wxFont::SetStyle(int style) +void wxFont::SetStyle( + int nStyle +) { Unshare(); - M_FONTDATA->m_style = style; + M_FONTDATA->SetStyle(nStyle); RealizeResource(); -} +} // end of wxFont::SetStyle -void wxFont::SetWeight(int weight) +void wxFont::SetWeight( + int nWeight +) { Unshare(); - M_FONTDATA->m_weight = weight; + M_FONTDATA->SetWeight(nWeight); RealizeResource(); -} +} // end of wxFont::SetWeight -void wxFont::SetFaceName(const wxString& faceName) +void wxFont::SetFaceName( + const wxString& rsFaceName +) { Unshare(); - M_FONTDATA->m_faceName = faceName; + M_FONTDATA->SetFaceName(rsFaceName); RealizeResource(); -} +} // end of wxFont::SetFaceName + +void wxFont::SetUnderlined( + bool bUnderlined +) +{ + Unshare(); + + M_FONTDATA->SetUnderlined(bUnderlined); + + RealizeResource(); +} // end of wxFont::SetUnderlined + +void wxFont::SetEncoding( + wxFontEncoding vEncoding +) +{ + Unshare(); + + M_FONTDATA->SetEncoding(vEncoding); -void wxFont::SetUnderlined(bool underlined) + RealizeResource(); +} // end of wxFont::SetEncoding + +void wxFont::SetNativeFontInfo( + const wxNativeFontInfo& rInfo +) { Unshare(); - M_FONTDATA->m_underlined = underlined; + FreeResource(); + + *M_FONTDATA = wxFontRefData(rInfo); RealizeResource(); } -wxString wxFont::GetFamilyString() const -{ - wxString fam(""); - switch (GetFamily()) - { - case wxDECORATIVE: - fam = "wxDECORATIVE"; - break; - case wxROMAN: - fam = "wxROMAN"; - break; - case wxSCRIPT: - fam = "wxSCRIPT"; - break; - case wxSWISS: - fam = "wxSWISS"; - break; - case wxMODERN: - fam = "wxMODERN"; - break; - case wxTELETYPE: - fam = "wxTELETYPE"; - break; - default: - fam = "wxDEFAULT"; - break; - } - return fam; +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- + +int wxFont::GetPointSize() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetPointSize(); +} // end of wxFont::GetPointSize + +int wxFont::GetFamily() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetFamily(); +} // end of wxFont::GetFamily + +int wxFont::GetStyle() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetStyle(); +} // end of wxFont::GetStyle + +int wxFont::GetWeight() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetWeight(); } -/* New font system */ +bool wxFont::GetUnderlined() const +{ + wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") ); + + return M_FONTDATA->GetUnderlined(); +} // end of wxFont::GetUnderlined + wxString wxFont::GetFaceName() const { - wxString str(""); - if (M_FONTDATA) - str = M_FONTDATA->m_faceName ; - return str; -} + wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") ); + + return M_FONTDATA->GetFaceName(); +} // end of wxFont::GetFaceName -wxString wxFont::GetStyleString() const +wxFontEncoding wxFont::GetEncoding() const { - wxString styl(""); - switch (GetStyle()) - { - case wxITALIC: - styl = "wxITALIC"; - break; - case wxSLANT: - styl = "wxSLANT"; - break; - default: - styl = "wxNORMAL"; - break; - } - return styl; -} + wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + + return M_FONTDATA->GetEncoding(); +} // end of wxFont::GetEncoding -wxString wxFont::GetWeightString() const +wxNativeFontInfo* wxFont::GetNativeFontInfo() const { - wxString w(""); - switch (GetWeight()) - { - case wxBOLD: - w = "wxBOLD"; - break; - case wxLIGHT: - w = "wxLIGHT"; - break; - default: - w = "wxNORMAL"; - break; - } - return w; -} + if (M_FONTDATA->HasNativeFontInfo()) + return new wxNativeFontInfo(M_FONTDATA->GetNativeFontInfo()); + return 0; +} // end of wxFont::GetNativeFontInfo + +// +// Internal use only method to set the FONTMETRICS array +// +void wxFont::SetFM( + PFONTMETRICS pFM +, int nNumFonts +) +{ + M_FONTDATA->SetFM(pFM); + M_FONTDATA->SetNumFonts(nNumFonts); +} // end of wxFont::SetFM + + +void wxFont::SetPS( + HPS hPS +) +{ + Unshare(); + + M_FONTDATA->SetPS(hPS); + + RealizeResource(); +} // end of wxFont::SetUnderlined