X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7e99520bd3fc092bbbcbc38bb699a0236618ea40..2bc4cc1ead29f6de1f0576a416025edadb13d7cc:/src/os2/font.cpp diff --git a/src/os2/font.cpp b/src/os2/font.cpp index 19c715f7a2..80ebeb2682 100644 --- a/src/os2/font.cpp +++ b/src/os2/font.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: font.cpp +// Name: src/os2/font.cpp // Purpose: wxFont class // Author: David Webster // Modified by: @@ -8,36 +8,9 @@ // Copyright: (c) David Webster // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#define DEBUG_PRINTF(NAME) { static int raz=0; \ - printf( #NAME " %i\n",raz); fflush(stdout); \ - raz++; \ - } - - #include - #include - - int HeapCheck(void) - { - int rc; - - if (_HEAPOK != (rc = _heapchk())) - { - switch(rc) - { - case _HEAPEMPTY: - puts("The heap has not been initialized."); - break; - case _HEAPBADNODE: - puts("A memory node is corrupted or the heap is damaged."); - break; - case _HEAPBADBEGIN: - puts("The heap specified is not valid."); - break; - } - fflush(stdout); - } - return 0; - } + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" // ============================================================================ // declarations @@ -47,26 +20,25 @@ // headers // ---------------------------------------------------------------------------- - #include -// For compilers that support precompilation, includes "wx.h". -#include "wx/wxprec.h" +#include "wx/font.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" + #include "wx/log.h" #endif // WX_PRECOMP #include "wx/os2/private.h" - IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#include "wx/fontutil.h" +#include "wx/fontmap.h" +#include "wx/encinfo.h" + +#include "wx/tokenzr.h" - #if wxUSE_PORTABLE_FONTS_IN_MSW - IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject) - #endif +#include // ---------------------------------------------------------------------------- // wxFontRefData - the internal description of the font @@ -74,64 +46,256 @@ class WXDLLEXPORT wxFontRefData: public wxGDIRefData { -friend class WXDLLEXPORT wxFont; - public: wxFontRefData() { - Init(12, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE, - "", wxFONTENCODING_DEFAULT); + Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, + wxEmptyString, wxFONTENCODING_DEFAULT); } - wxFontRefData(const wxFontRefData& data) + wxFontRefData( int nSize + ,wxFontFamily nFamily + ,wxFontStyle nStyle + ,wxFontWeight nWeight + ,bool bUnderlined + ,const wxString& sFaceName + ,wxFontEncoding vEncoding + ) { - Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, - data.m_underlined, data.m_faceName, data.m_encoding); + Init( nSize + ,nFamily + ,nStyle + ,nWeight + ,bUnderlined + ,sFaceName + ,vEncoding + ); + } - m_fontId = data.m_fontId; + wxFontRefData( const wxNativeFontInfo& rInfo + ,WXHFONT hFont = 0 + ,WXHANDLE hPS = 0 + ) + { + Init( rInfo + ,hFont + ,hPS + ); } - wxFontRefData(int size, - int family, - int style, - int weight, - bool underlined, - const wxString& faceName, - wxFontEncoding encoding) + wxFontRefData(const wxFontRefData& rData) { - Init(size, family, style, weight, underlined, faceName, encoding); + 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(); -protected: - // common part of all ctors - void Init(int size, - int family, - int style, - int weight, - bool underlined, - const wxString& faceName, - wxFontEncoding encoding); - - // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE - // DELETED by destructor - bool m_temporary; + // + // 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 wxFontFamily GetFamily(void) const + { + return m_nFamily; + } + + inline wxFontStyle GetStyle(void) const + { + return m_bNativeFontInfoOk ? m_vNativeFontInfo.GetStyle() + : m_nStyle; + } + + inline wxFontWeight 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; + } - int m_fontId; + 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(wxFontFamily nFamily) + { + m_nFamily = nFamily; + } + + inline void SetStyle(wxFontStyle nStyle) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetStyle(nStyle); + else + m_nStyle = nStyle; + } - // font characterstics - int m_pointSize; - int m_family; - int m_style; - int m_weight; - bool m_underlined; - wxString m_faceName; - wxFontEncoding m_encoding; + inline void SetWeight(wxFontWeight nWeight) + { + if (m_bNativeFontInfoOk) + m_vNativeFontInfo.SetWeight(nWeight); + else + m_nWeight = nWeight; + } - // Windows font handle - WXHFONT m_hFont; -}; + inline bool SetFaceName(const wxString& sFaceName) + { + if (m_bNativeFontInfoOk) + return m_vNativeFontInfo.SetFaceName(sFaceName); + else + m_sFaceName = sFaceName; + return true; + } + + 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 + ,wxFontFamily nFamily + ,wxFontStyle nStyle + ,wxFontWeight 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; + wxFontFamily m_nFamily; + wxFontStyle m_nStyle; + wxFontWeight 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 + +#define M_FONTDATA ((wxFontRefData*)m_refData) // ============================================================================ // implementation @@ -141,413 +305,766 @@ protected: // wxFontRefData // ---------------------------------------------------------------------------- -void wxFontRefData::Init(int pointSize, - int family, - int style, - int weight, - bool underlined, - const wxString& faceName, - wxFontEncoding encoding) -{ - m_style = style; - m_pointSize = pointSize; - m_family = family; - m_style = style; - m_weight = weight; - m_underlined = underlined; - m_faceName = faceName; - m_encoding = encoding; - - m_fontId = 0; - m_temporary = FALSE; - - m_hFont = 0; -} +void wxFontRefData::Init( + int nPointSize +, wxFontFamily nFamily +, wxFontStyle nStyle +, wxFontWeight 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 (hPS == NULLHANDLE) + { + m_hPS = ::WinGetPS(HWND_DESKTOP); + m_bInternalPS = true; + } + else + m_hPS = (HPS)hPS; + + m_nFontId = 0; + m_bTemporary = false; + m_pFM = (PFONTMETRICS)NULL; + m_nNumFonts = 0; +} // end of wxFontRefData::Init wxFontRefData::~wxFontRefData() { -DEBUG_PRINTF(wxFontRefData::~wxFontRefData!!!) -// TODO: -// if ( m_hFont ) -// { -// if ( !::DeleteObject((HFONT) m_hFont) ) -// { -// wxLogLastError("DeleteObject(font)"); -// } -// } + Free(); } -// ---------------------------------------------------------------------------- -// wxFont -// ---------------------------------------------------------------------------- - -void wxFont::Init() +bool wxFontRefData::Alloc( wxFont* pFont ) { + wxString sFaceName; + long flId = m_hFont; + long lRc; + ERRORID vError; + wxString sError; -DEBUG_PRINTF(wxFontRefData::~wxFontRefData!!!) + if (!m_bNativeFontInfoOk) + { + wxFillLogFont( &m_vNativeFontInfo.fa + ,&m_vNativeFontInfo.fn + ,&m_hPS + ,&m_bInternalPS + ,&flId + ,sFaceName + ,pFont + ); + m_bNativeFontInfoOk = true; + } + else + { + if (flId == 0L) + flId = 1L; + else + flId++; + if (flId > 254) + flId = 1L; + } + if((lRc = ::GpiCreateLogFont( m_hPS + ,NULL + ,flId + ,&m_vNativeFontInfo.fa + )) != GPI_ERROR) + { + m_hFont = (WXHFONT)flId; + m_nFontId = flId; + } + if (!m_hFont) + { + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + wxLogLastError(wxT("CreateFont")); + } - if ( wxTheFontList ) - wxTheFontList->Append(this); -} + ::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.fm.szFamilyname, "Times New Roman") == 0) + m_nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Times New Roman MT 30") == 0) + m_nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "@Times New Roman MT 30") == 0) + m_nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Tms Rmn") == 0) + m_nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "WarpSans") == 0) + m_nFamily = wxFONTFAMILY_DECORATIVE; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helvetica") == 0) + m_nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Helv") == 0) + m_nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Script") == 0) + m_nFamily = wxFONTFAMILY_SCRIPT; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier New") == 0) + m_nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Courier") == 0) + m_nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Monospaced") == 0) + m_nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System VIO") == 0) + m_nFamily = wxFONTFAMILY_MODERN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "System Proportional") == 0) + m_nFamily = wxFONTFAMILY_MODERN; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Arial") == 0) + m_nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(m_vNativeFontInfo.fm.szFamilyname, "Swiss") == 0) + m_nFamily = wxFONTFAMILY_SWISS; + else + m_nFamily = wxFONTFAMILY_SWISS; -/* 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 pointSize, - int family, - int style, - int weight, - bool underlined, - const wxString& faceName, - wxFontEncoding encoding) -{ - UnRef(); -DEBUG_PRINTF(wxFontRefData::~wxFontRefData!!!) - m_refData = new wxFontRefData(pointSize, family, style, weight, - underlined, faceName, encoding); + 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; - RealizeResource(); + case FWEIGHT_NORMAL: + m_nWeight = wxFONTWEIGHT_NORMAL; + break; - return TRUE; -} + case FWEIGHT_LIGHT: + m_nWeight = wxFONTWEIGHT_LIGHT; + break; -wxFont::~wxFont() -{ - int l; - l = sizeof(*this); -HeapCheck(); - _heap_check(); + case FWEIGHT_BOLD: + m_nWeight = wxFONTWEIGHT_BOLD; + break; - if ( wxTheFontList ) - wxTheFontList->DeleteObject(this); -HeapCheck(); - _heap_check(); + 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 = (wxChar*)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() +{ + if (m_pFM) + delete [] m_pFM; + m_pFM = (PFONTMETRICS)NULL; + + if ( m_hFont ) + { + ::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 // ---------------------------------------------------------------------------- -// 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 +// wxNativeFontInfo // ---------------------------------------------------------------------------- -bool wxFont::RealizeResource() +void wxNativeFontInfo::Init() { -DEBUG_PRINTF(wxFont::RealizeResource) - if ( GetResourceHandle() ) - { - // VZ: the old code returned FALSE in this case, but it doesn't seem - // to make sense because the font _was_ created - wxLogDebug(wxT("Calling wxFont::RealizeResource() twice")); + memset(&fa, '\0', sizeof(FATTRS)); +} // end of wxNativeFontInfo::Init - return TRUE; - } +int wxNativeFontInfo::GetPointSize() const +{ + return fm.lEmHeight; +} // end of wxNativeFontInfo::GetPointSize - HPS hps; - FATTRS fAttrs; - FACENAMEDESC fName; - LONG fLid; +wxFontStyle wxNativeFontInfo::GetStyle() const +{ + return fa.fsSelection & FATTR_SEL_ITALIC ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; +} // end of wxNativeFontInfo::GetStyle - fAttrs.usRecordLength = sizeof(FATTRS); - fAttrs.fsFontUse = FATTR_FONTUSE_OUTLINE | // only outline fonts allowed - FATTR_FONTUSE_TRANSFORMABLE; // may be transformed - fAttrs.fsType = 0; - fAttrs.lMaxBaselineExt = fAttrs.lAveCharWidth = 0; - fAttrs.idRegistry = 0; - fAttrs.lMatch = 0; +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + switch(fn.usWeightClass) + { + case FWEIGHT_DONT_CARE: + return wxFONTWEIGHT_NORMAL; - fName.usSize = sizeof(FACENAMEDESC); - fName.usWidthClass = FWIDTH_NORMAL; - fName.usReserved = 0; - fName.flOptions = 0; + case FWEIGHT_NORMAL: + return wxFONTWEIGHT_NORMAL; - wxString ff_face; + case FWEIGHT_LIGHT: + return wxFONTWEIGHT_LIGHT; -// OS/2 combines the family with styles to give a facename + case FWEIGHT_BOLD: + return wxFONTWEIGHT_BOLD; - switch ( M_FONTDATA->m_family ) - { - case wxSCRIPT: - case wxDECORATIVE: - case wxROMAN: - ff_face = wxT("Times New Roman") ; - break; + case FWEIGHT_ULTRA_BOLD: + return wxFONTWEIGHT_MAX; + } + return wxFONTWEIGHT_NORMAL; +} // end of wxNativeFontInfo::GetWeight - case wxTELETYPE: - case wxMODERN: - ff_face = wxT("Courier") ; - break; +bool wxNativeFontInfo::GetUnderlined() const +{ + return ((fa.fsSelection & FATTR_SEL_UNDERSCORE) != 0); +} // end of wxNativeFontInfo::GetUnderlined - case wxSWISS: - case wxDEFAULT: - default: - ff_face = wxT("Helvetica") ; - } +wxString wxNativeFontInfo::GetFaceName() const +{ + return (wxChar*)fm.szFacename; +} // end of wxNativeFontInfo::GetFaceName - switch ( M_FONTDATA->m_style ) - { - case wxITALIC: - case wxSLANT: - fAttrs.fsSelection = FATTR_SEL_ITALIC; - break; +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + int nFamily; + + // + // Extract family from facename + // + if (strcmp(fm.szFamilyname, "Times New Roman") == 0) + nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(fm.szFamilyname, "Times New Roman MT 30") == 0) + nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(fm.szFamilyname, "@Times New Roman MT 30") == 0) + nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(fm.szFamilyname, "Tms Rmn") == 0) + nFamily = wxFONTFAMILY_ROMAN; + else if (strcmp(fm.szFamilyname, "WarpSans") == 0) + nFamily = wxFONTFAMILY_DECORATIVE; + else if (strcmp(fm.szFamilyname, "Helvetica") == 0) + nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(fm.szFamilyname, "Helv") == 0) + nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(fm.szFamilyname, "Script") == 0) + nFamily = wxFONTFAMILY_SCRIPT; + else if (strcmp(fm.szFamilyname, "Courier New") == 0) + nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(fm.szFamilyname, "Courier") == 0) + nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(fm.szFamilyname, "System Monospaced") == 0) + nFamily = wxFONTFAMILY_TELETYPE; + else if (strcmp(fm.szFamilyname, "System VIO") == 0) + nFamily = wxFONTFAMILY_MODERN; + else if (strcmp(fm.szFamilyname, "System Proportional") == 0) + nFamily = wxFONTFAMILY_MODERN; + else if (strcmp(fm.szFamilyname, "Arial") == 0) + nFamily = wxFONTFAMILY_SWISS; + else if (strcmp(fm.szFamilyname, "Swiss") == 0) + nFamily = wxFONTFAMILY_SWISS; + else + nFamily = wxFONTFAMILY_SWISS; + return (wxFontFamily)nFamily; +} // end of wxNativeFontInfo::GetFamily - default: - wxFAIL_MSG(wxT("unknown font slant")); - // fall through +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxGetFontEncFromCharSet(fa.usCodePage); +} // end of wxNativeFontInfo::GetEncoding - case wxNORMAL: - fAttrs.fsSelection = 0; - } +void wxNativeFontInfo::SetPointSize( + int nPointsize +) +{ + fm.lEmHeight = (LONG)nPointsize; +} // end of wxNativeFontInfo::SetPointSize - switch ( M_FONTDATA->m_weight ) +void wxNativeFontInfo::SetStyle( + wxFontStyle eStyle +) +{ + switch (eStyle) { default: - wxFAIL_MSG(wxT("unknown font weight")); + wxFAIL_MSG( wxT("unknown font style") ); // fall through - case wxNORMAL: - fName.usWeightClass = FWEIGHT_NORMAL; - break; - - case wxLIGHT: - fName.usWeightClass = FWEIGHT_LIGHT; + case wxFONTSTYLE_NORMAL: break; - case wxBOLD: - fName.usWeightClass = FWEIGHT_BOLD; + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + fa.fsSelection |= FATTR_SEL_ITALIC; break; } +} // end of wxNativeFontInfo::SetStyle - if( M_FONTDATA->m_underlined ) - fAttrs.fsSelection |= FATTR_SEL_UNDERSCORE; - - wxFontEncoding encoding = M_FONTDATA->m_encoding; - if ( encoding == wxFONTENCODING_DEFAULT ) +void wxNativeFontInfo::SetWeight( + wxFontWeight eWeight +) +{ + switch (eWeight) { - encoding = wxFont::GetDefaultEncoding(); - } + default: + wxFAIL_MSG( wxT("unknown font weight") ); + // fall through - switch ( encoding ) - { - case wxFONTENCODING_ISO8859_1: - case wxFONTENCODING_ISO8859_15: - case wxFONTENCODING_CP1250: - fAttrs.usCodePage = 1250; + case wxFONTWEIGHT_NORMAL: + fn.usWeightClass = FWEIGHT_NORMAL; break; - case wxFONTENCODING_ISO8859_2: - case wxFONTENCODING_CP1252: - fAttrs.usCodePage = 1252; + case wxFONTWEIGHT_LIGHT: + fn.usWeightClass = FWEIGHT_LIGHT; break; - case wxFONTENCODING_ISO8859_4: - case wxFONTENCODING_ISO8859_10: - fAttrs.usCodePage = 850; // what is baltic? + case wxFONTWEIGHT_BOLD: + fn.usWeightClass = FWEIGHT_BOLD; break; + } +} // end of wxNativeFontInfo::SetWeight - case wxFONTENCODING_ISO8859_5: - case wxFONTENCODING_CP1251: - fAttrs.usCodePage = 1251; - break; +void wxNativeFontInfo::SetUnderlined( + bool bUnderlined +) +{ + if(bUnderlined) + fa.fsSelection |= FATTR_SEL_UNDERSCORE; +} // end of wxNativeFontInfo::SetUnderlined - case wxFONTENCODING_ISO8859_6: - fAttrs.usCodePage = 850; // what is arabic? +bool wxNativeFontInfo::SetFaceName( + const wxString& sFacename +) +{ + wxStrlcpy((wxChar*)fa.szFacename, sFacename, WXSIZEOF(fa.szFacename)); + return true; +} // end of wxNativeFontInfo::SetFaceName + +void wxNativeFontInfo::SetFamily( + wxFontFamily eFamily +) +{ + wxString sFacename; + + switch (eFamily) + { + case wxFONTFAMILY_SCRIPT: + sFacename = wxT("Tms Rmn"); break; - case wxFONTENCODING_ISO8859_7: - fAttrs.usCodePage = 850; // what is greek + case wxFONTFAMILY_DECORATIVE: + sFacename = wxT("WarpSans"); break; - case wxFONTENCODING_ISO8859_8: - fAttrs.usCodePage = 850; // what is hebrew? + case wxFONTFAMILY_ROMAN: + sFacename = wxT("Tms Rmn"); break; - case wxFONTENCODING_ISO8859_9: - fAttrs.usCodePage = 857; + case wxFONTFAMILY_TELETYPE: + sFacename = wxT("Courier") ; break; - case wxFONTENCODING_ISO8859_11: - fAttrs.usCodePage = 850; // what is thai + case wxFONTFAMILY_MODERN: + sFacename = wxT("System VIO") ; break; - case wxFONTENCODING_CP437: - fAttrs.usCodePage = 437; + case wxFONTFAMILY_SWISS: + sFacename = wxT("Helv") ; break; + case wxFONTFAMILY_DEFAULT: default: - wxFAIL_MSG(wxT("unsupported encoding")); - // fall through - - case wxFONTENCODING_SYSTEM: - fAttrs.usCodePage = 850; // what is ANSI? - break; + sFacename = wxT("System VIO") ; } -// Now cheking - fLid = 1; - hps = ::WinGetPS( HWND_DESKTOP ); + if (!wxStrlen((wxChar*)fa.szFacename) ) + { + SetFaceName(sFacename); + } +} // end of wxNativeFontInfo::SetFamily - long numLids = ::GpiQueryNumberSetIds( hps ); - long gpiError; +void wxNativeFontInfo::SetEncoding( wxFontEncoding eEncoding ) +{ + wxNativeEncodingInfo vInfo; - // First we should generate unique id - if( numLids ) + if ( !wxGetNativeFontEncoding( eEncoding + ,&vInfo + )) { - long Types[255]; - STR8 Names[255]; - long lIds[255]; - - if( !GpiQuerySetIds(hps, numLids, Types, Names, lIds) ) + if (wxFontMapper::Get()->GetAltForEncoding( eEncoding + ,&vInfo + )) { - ::WinReleasePS( hps ); - return 0; + 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); + } } - - for(unsigned long LCNum = 0; LCNum < numLids; LCNum++) - if(lIds[LCNum] == fLid) - ++fLid; - if(fLid > 254) // wow, no id available! + else { - ::WinReleasePS( hps ); - return 0; + // unsupported encoding, replace with the default + vInfo.charset = 850; } } + fa.usCodePage = (USHORT)vInfo.charset; +} // end of wxNativeFontInfo::SetFaceName - // now building facestring - if(::GpiQueryFaceString(hps, ff_face.c_str(), &fName, FACESIZE, fAttrs.szFacename) == GPI_ERROR) - { - ::WinReleasePS( hps ); - return 0; - } +bool wxNativeFontInfo::FromString( const wxString& rsStr ) +{ + long lVal; + + wxStringTokenizer vTokenizer(rsStr, wxT(";")); + + // + // First the version + // + wxString sToken = vTokenizer.GetNextToken(); + + if (sToken != wxT('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((wxChar*)fa.szFacename, sToken.c_str()); + return true; +} // end of wxNativeFontInfo::FromString + +wxString wxNativeFontInfo::ToString() const +{ + wxString sStr; + + sStr.Printf(wxT("%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, + (char *)fa.szFacename); + return sStr; +} // end of wxNativeFontInfo::ToString - // now creating font - WXHFONT hFont = (WXHFONT)0; +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- - if(::GpiCreateLogFont(hps, NULL, fLid, &fAttrs) != GPI_ERROR) - M_FONTDATA->m_hFont = hFont = (WXHFONT)1; +bool wxFont::Create( const wxNativeFontInfo& rInfo, + WXHFONT hFont ) +{ + UnRef(); + m_refData = new wxFontRefData( rInfo + ,hFont + ); + RealizeResource(); + return true; +} // end of wxFont::Create - if( hFont ) - ::GpiDeleteSetId(hps, fLid); +wxFont::wxFont( + const wxString& rsFontdesc +) +{ + wxNativeFontInfo vInfo; - ::WinReleasePS( hps ); + if (vInfo.FromString(rsFontdesc)) + (void)Create(vInfo); +} // end of wxFont::wxFont - if ( !hFont ) +// ---------------------------------------------------------------------------- +// 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, + wxFontFamily nFamily, + wxFontStyle nStyle, + wxFontWeight 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) { - wxLogLastError("CreateFont"); + nPointSize = wxNORMAL_FONT->GetPointSize(); } + m_refData = new wxFontRefData( nPointSize + ,nFamily + ,nStyle + ,nWeight + ,bUnderlined + ,rsFaceName + ,vEncoding + ); + RealizeResource(); + return true; +} // end of wxFont::Create - return hFont != 0; -} - -bool wxFont::FreeResource(bool force) +wxFont::~wxFont() { - if ( GetResourceHandle() ) - { -// TODO: -// if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) ) -// { -// wxLogLastError("DeleteObject(font)"); -// } +} // end of wxFont::~wxFont - M_FONTDATA->m_hFont = 0; - - return TRUE; - } - return FALSE; -} +// ---------------------------------------------------------------------------- +// real implementation +// Boris' Kovalenko comments: +// Because OS/2 fonts are associated with PS we cannot create the font +// here, but we may check that font definition is true +// ---------------------------------------------------------------------------- -WXHANDLE wxFont::GetResourceHandle() +wxGDIRefData *wxFont::CreateGDIRefData() const { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont ; + return new wxFontRefData(); } -bool wxFont::IsFree() const +wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const { - return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); + return new wxFontRefData(*static_cast(data)); } -void wxFont::Unshare() +bool wxFont::RealizeResource() { - // Don't change shared data - if ( !m_refData ) + if ( GetResourceHandle() ) { - m_refData = new wxFontRefData(); + return true; } - else + return M_FONTDATA->Alloc(this); +} // end of wxFont::RealizeResource + +bool wxFont::FreeResource( bool WXUNUSED(bForce) ) +{ + if (GetResourceHandle()) { - wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); - UnRef(); - m_refData = ref; + M_FONTDATA->Free(); + return true; } -} + return false; +} // end of wxFont::FreeResource + +WXHANDLE wxFont::GetResourceHandle() const +{ + 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 // ---------------------------------------------------------------------------- // change font attribute: we recreate font when doing it // ---------------------------------------------------------------------------- -void wxFont::SetPointSize(int pointSize) +void wxFont::SetPointSize( + int nPointSize +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_pointSize = pointSize; + M_FONTDATA->SetPointSize(nPointSize); RealizeResource(); -} +} // end of wxFont::SetPointSize -void wxFont::SetFamily(int family) +void wxFont::SetFamily( + wxFontFamily nFamily +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_family = family; + M_FONTDATA->SetFamily(nFamily); RealizeResource(); -} +} // end of wxFont::SetFamily -void wxFont::SetStyle(int style) +void wxFont::SetStyle( + wxFontStyle nStyle +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_style = style; + M_FONTDATA->SetStyle(nStyle); RealizeResource(); -} +} // end of wxFont::SetStyle -void wxFont::SetWeight(int weight) +void wxFont::SetWeight( + wxFontWeight nWeight +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_weight = weight; + M_FONTDATA->SetWeight(nWeight); RealizeResource(); -} +} // end of wxFont::SetWeight -void wxFont::SetFaceName(const wxString& faceName) +bool wxFont::SetFaceName( + const wxString& rsFaceName +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_faceName = faceName; + bool refdataok = M_FONTDATA->SetFaceName(rsFaceName); RealizeResource(); -} -void wxFont::SetUnderlined(bool underlined) + return refdataok && wxFontBase::SetFaceName(rsFaceName); +} // end of wxFont::SetFaceName + +void wxFont::SetUnderlined( + bool bUnderlined +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_underlined = underlined; + M_FONTDATA->SetUnderlined(bUnderlined); RealizeResource(); -} +} // end of wxFont::SetUnderlined -void wxFont::SetEncoding(wxFontEncoding encoding) +void wxFont::SetEncoding( + wxFontEncoding vEncoding +) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_encoding = encoding; + M_FONTDATA->SetEncoding(vEncoding); + + RealizeResource(); +} // end of wxFont::SetEncoding + +void wxFont::DoSetNativeFontInfo( + const wxNativeFontInfo& rInfo +) +{ + AllocExclusive(); + + FreeResource(); + + *M_FONTDATA = wxFontRefData(rInfo); RealizeResource(); } @@ -558,51 +1075,72 @@ void wxFont::SetEncoding(wxFontEncoding encoding) int wxFont::GetPointSize() const { -DEBUG_PRINTF(wxFont::GetPointSize) - wxFontRefData* pTmp; + wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); - pTmp = M_FONTDATA; - if(pTmp) - return pTmp->m_pointSize; - else - return 10; -} + return M_FONTDATA->GetPointSize(); +} // end of wxFont::GetPointSize -int wxFont::GetFamily() const +wxFontFamily wxFont::DoGetFamily() const { - return M_FONTDATA->m_family; -} + return M_FONTDATA->GetFamily(); +} // end of wxFont::DoGetFamily -int wxFont::GetFontId() const +wxFontStyle wxFont::GetStyle() const { - return M_FONTDATA->m_fontId; -} + wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") ); -int wxFont::GetStyle() const -{ - return M_FONTDATA->m_style; -} + return M_FONTDATA->GetStyle(); +} // end of wxFont::GetStyle -int wxFont::GetWeight() const +wxFontWeight wxFont::GetWeight() const { - return M_FONTDATA->m_weight; + wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") ); + + return M_FONTDATA->GetWeight(); } bool wxFont::GetUnderlined() const { - return M_FONTDATA->m_underlined; -} + wxCHECK_MSG( IsOk(), 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( IsOk(), wxEmptyString, wxT("invalid font") ); + + return M_FONTDATA->GetFaceName(); +} // end of wxFont::GetFaceName wxFontEncoding wxFont::GetEncoding() const { - return M_FONTDATA->m_encoding; -} + wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + return M_FONTDATA->GetEncoding(); +} // end of wxFont::GetEncoding + +const wxNativeFontInfo* wxFont::GetNativeFontInfo() const +{ + return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo()) + : NULL; +} // 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 ) +{ + AllocExclusive(); + + M_FONTDATA->SetPS(hPS); + + RealizeResource(); +} // end of wxFont::SetPS