X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/debe6624c1e9d4bf3243381153d1e173c849bcd8..9f8130d6b3012265895fd69ce394c443c045b709:/src/msw/font.cpp diff --git a/src/msw/font.cpp b/src/msw/font.cpp index 48a127d8f9..d335ae6fce 100644 --- a/src/msw/font.cpp +++ b/src/msw/font.cpp @@ -1,362 +1,1051 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: font.cpp +// Name: src/msw/font.cpp // Purpose: wxFont class // Author: Julian Smart // Modified by: // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows licence +// Copyright: (c) wxWidgets team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "font.h" -#endif +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop #endif #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 + #include "wx/setup.h" + #include "wx/list.h" + #include "wx/utils.h" + #include "wx/app.h" + #include "wx/font.h" + #include "wx/log.h" + #include "wx/encinfo.h" +#endif // WX_PRECOMP #include "wx/msw/private.h" -#include "assert.h" -#if !USE_SHARED_LIBRARIES -IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#include "wx/fontutil.h" +#include "wx/fontmap.h" -#if USE_PORTABLE_FONTS_IN_MSW -IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject) -#endif +#include "wx/tokenzr.h" + +#if wxUSE_EXTENDED_RTTI + +wxBEGIN_ENUM( wxFontFamily ) + wxENUM_MEMBER( wxDEFAULT ) + wxENUM_MEMBER( wxDECORATIVE ) + wxENUM_MEMBER( wxROMAN ) + wxENUM_MEMBER( wxSCRIPT ) + wxENUM_MEMBER( wxSWISS ) + wxENUM_MEMBER( wxMODERN ) + wxENUM_MEMBER( wxTELETYPE ) +wxEND_ENUM( wxFontFamily ) + +wxBEGIN_ENUM( wxFontStyle ) + wxENUM_MEMBER( wxNORMAL ) + wxENUM_MEMBER( wxITALIC ) + wxENUM_MEMBER( wxSLANT ) +wxEND_ENUM( wxFontStyle ) + +wxBEGIN_ENUM( wxFontWeight ) + wxENUM_MEMBER( wxNORMAL ) + wxENUM_MEMBER( wxLIGHT ) + wxENUM_MEMBER( wxBOLD ) +wxEND_ENUM( wxFontWeight ) + +IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont, wxGDIObject,"wx/font.h") + +wxBEGIN_PROPERTIES_TABLE(wxFont) + wxPROPERTY( Size,int, SetPointSize, GetPointSize, 12 , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Family, int , SetFamily, GetFamily, (int)wxDEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontFamily + wxPROPERTY( Style, int , SetStyle, GetStyle, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontStyle + wxPROPERTY( Weight, int , SetWeight, GetWeight, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontWeight + wxPROPERTY( Underlined, bool , SetUnderlined, GetUnderlined, false , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Face, wxString , SetFaceName, GetFaceName, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Encoding, wxFontEncoding , SetEncoding, GetEncoding, wxFONTENCODING_DEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) +wxEND_PROPERTIES_TABLE() + +wxCONSTRUCTOR_6( wxFont , int , Size , int , Family , int , Style , int , Weight , bool , Underlined , wxString , Face ) +wxBEGIN_HANDLERS_TABLE(wxFont) +wxEND_HANDLERS_TABLE() + +#else + IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) #endif -wxFontRefData::wxFontRefData(void) + +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +// the mask used to extract the pitch from LOGFONT::lfPitchAndFamily field +static const int PITCH_MASK = FIXED_PITCH | VARIABLE_PITCH; + +// ---------------------------------------------------------------------------- +// wxFontRefData - the internal description of the font +// ---------------------------------------------------------------------------- + +class WXDLLEXPORT wxFontRefData: public wxGDIRefData +{ +public: + // constructors + wxFontRefData() + { + Init(-1, wxSize(0,0), false, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, + wxFONTWEIGHT_NORMAL, false, wxEmptyString, + wxFONTENCODING_DEFAULT); + } + + wxFontRefData(int size, + const wxSize& pixelSize, + bool sizeUsingPixels, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) + { + Init(size, pixelSize, sizeUsingPixels, family, style, weight, + underlined, faceName, encoding); + } + + wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0) + { + Init(info, hFont); + } + + wxFontRefData(const wxFontRefData& data) : wxGDIRefData() + { + if ( data.m_nativeFontInfoOk ) + { + Init(data.m_nativeFontInfo); + } + else + { + Init(data.m_pointSize, data.m_pixelSize, data.m_sizeUsingPixels, + data.m_family, data.m_style, data.m_weight, + data.m_underlined, data.m_faceName, data.m_encoding); + } + } + + virtual ~wxFontRefData(); + + // operations + bool Alloc(wxFont *font); + + void Free(); + + // all wxFont accessors + int GetPointSize() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetPointSize() + : m_pointSize; + } + + wxSize GetPixelSize() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetPixelSize() + : m_pixelSize; + } + + bool IsUsingSizeInPixels() const + { + return m_nativeFontInfoOk ? true : m_sizeUsingPixels; + } + + int GetFamily() const + { + return m_family; + } + + int GetStyle() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetStyle() + : m_style; + } + + int GetWeight() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetWeight() + : m_weight; + } + + bool GetUnderlined() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetUnderlined() + : m_underlined; + } + + wxString GetFaceName() const + { + wxString s; + if ( m_nativeFontInfoOk ) + s = m_nativeFontInfo.GetFaceName(); + else + s = m_faceName; + + return s; + } + + wxFontEncoding GetEncoding() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetEncoding() + : m_encoding; + } + + WXHFONT GetHFONT() const { return m_hFont; } + + // ... and setters + void SetPointSize(int pointSize) + { + if ( m_nativeFontInfoOk ) + { + m_nativeFontInfo.SetPointSize(pointSize); + } + else + { + m_pointSize = pointSize; + m_sizeUsingPixels = false; + } + } + + void SetPixelSize(const wxSize& pixelSize) + { + if ( m_nativeFontInfoOk ) + { + m_nativeFontInfo.SetPixelSize(pixelSize); + } + else + { + m_pixelSize = pixelSize; + m_sizeUsingPixels = true; + } + } + + void SetFamily(int family) + { + m_family = family; + } + + void SetStyle(int style) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetStyle((wxFontStyle)style); + else + m_style = style; + } + + void SetWeight(int weight) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetWeight((wxFontWeight)weight); + else + m_weight = weight; + } + + void SetFaceName(const wxString& faceName) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetFaceName(faceName); + else + m_faceName = faceName; + } + + void SetUnderlined(bool underlined) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetUnderlined(underlined); + else + m_underlined = underlined; + } + + void SetEncoding(wxFontEncoding encoding) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetEncoding(encoding); + else + m_encoding = encoding; + } + + // native font info tests + bool HasNativeFontInfo() const { return m_nativeFontInfoOk; } + + const wxNativeFontInfo& GetNativeFontInfo() const + { return m_nativeFontInfo; } + +protected: + // common part of all ctors + void Init(int size, + const wxSize& pixelSize, + bool sizeUsingPixels, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding); + + void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0); + + // font characterstics + int m_pointSize; + wxSize m_pixelSize; + bool m_sizeUsingPixels; + int m_family; + int m_style; + int m_weight; + bool m_underlined; + wxString m_faceName; + wxFontEncoding m_encoding; + + // Windows font handle + WXHFONT m_hFont; + + // Native font info + wxNativeFontInfo m_nativeFontInfo; + bool m_nativeFontInfoOk; +}; + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxFontRefData +// ---------------------------------------------------------------------------- + +void wxFontRefData::Init(int pointSize, + const wxSize& pixelSize, + bool sizeUsingPixels, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) { - m_style = 0; - m_temporary = FALSE; - m_pointSize = 0; - m_family = 0; - m_fontId = 0; - m_style = 0; - m_weight = 0; - m_underlined = 0; - m_faceName = ""; - m_hFont = 0; + m_style = style; + m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize; + m_pixelSize = pixelSize; + m_sizeUsingPixels = sizeUsingPixels; + m_family = family; + m_style = style; + m_weight = weight; + m_underlined = underlined; + m_faceName = faceName; + m_encoding = encoding; + + m_hFont = 0; + + m_nativeFontInfoOk = false; } -wxFontRefData::~wxFontRefData(void) +void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont) { - if ( m_hFont ) - ::DeleteObject((HFONT) m_hFont); + // 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_nativeFontInfoOk = true; + m_nativeFontInfo = info; + // This is the best we can do since we don't have the + // correct information at this point. + m_family = wxSWISS; } -wxFont::wxFont(void) +wxFontRefData::~wxFontRefData() { - if ( wxTheFontList ) - wxTheFontList->Append(this); + Free(); } -/* Constructor for a font. Note that the real construction is done - * in wxDC::SetFont, when information is available about scaling etc. - */ -wxFont::wxFont(int PointSize, int Family, int Style, int Weight, bool Underlined, const wxString& Face) +bool wxFontRefData::Alloc(wxFont *font) +{ + if ( !m_nativeFontInfoOk ) + { + wxFillLogFont(&m_nativeFontInfo.lf, font); + m_nativeFontInfoOk = true; + } + + HFONT hfont = ::CreateFontIndirect(&m_nativeFontInfo.lf); + if ( !hfont ) + { + wxLogLastError(wxT("CreateFont")); + + return false; + } + + m_hFont = (WXHFONT)hfont; + + return true; +} + +void wxFontRefData::Free() { - Create(PointSize, Family, Style, Weight, Underlined, Face); + if ( m_hFont ) + { + if ( !::DeleteObject((HFONT) m_hFont) ) + { + wxLogLastError(wxT("DeleteObject(font)")); + } - if ( wxTheFontList ) - wxTheFontList->Append(this); + m_hFont = 0; + } } -bool wxFont::Create(int PointSize, int Family, int Style, int Weight, bool Underlined, const wxString& Face) +// ---------------------------------------------------------------------------- +// wxNativeFontInfo +// ---------------------------------------------------------------------------- + +void wxNativeFontInfo::Init() { - UnRef(); - m_refData = new wxFontRefData; + wxZeroMemory(lf); +} - 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 = Face; - M_FONTDATA->m_temporary = FALSE; - M_FONTDATA->m_hFont = 0; +int wxNativeFontInfo::GetPointSize() const +{ + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); - RealizeResource(); + return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5); +} - return TRUE; +wxSize wxNativeFontInfo::GetPixelSize() const +{ + wxSize ret; + ret.SetHeight(lf.lfHeight); + ret.SetWidth(lf.lfWidth); + return ret; } -wxFont::~wxFont() +wxFontStyle wxNativeFontInfo::GetStyle() const { - if (wxTheFontList) - wxTheFontList->DeleteObject(this); -} - -bool wxFont::RealizeResource(void) -{ - if (M_FONTDATA && !M_FONTDATA->m_hFont) - { - BYTE ff_italic; - int ff_weight = 0; - int ff_family = 0; - wxString ff_face(""); - - switch (M_FONTDATA->m_family) - { - case wxSCRIPT: ff_family = FF_SCRIPT ; - ff_face = "Script" ; - break ; - case wxDECORATIVE: ff_family = FF_DECORATIVE; - break; - case wxROMAN: ff_family = FF_ROMAN; - ff_face = "Times New Roman" ; - break; - case wxTELETYPE: - case wxMODERN: ff_family = FF_MODERN; - ff_face = "Courier New" ; - break; - case wxSWISS: ff_family = FF_SWISS; - ff_face = "Arial"; - break; - case wxDEFAULT: - default: ff_family = FF_SWISS; - ff_face = "Arial" ; - } - - if (M_FONTDATA->m_style == wxITALIC || M_FONTDATA->m_style == wxSLANT) - ff_italic = 1; - else - ff_italic = 0; + return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; +} - if (M_FONTDATA->m_weight == wxNORMAL) - ff_weight = FW_NORMAL; - else if (M_FONTDATA->m_weight == wxLIGHT) - ff_weight = FW_LIGHT; - else if (M_FONTDATA->m_weight == wxBOLD) - ff_weight = FW_BOLD; +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + if ( lf.lfWeight <= 300 ) + return wxFONTWEIGHT_LIGHT; -#if defined(__X__) || (defined(__WINDOWS__) && USE_PORTABLE_FONTS_IN_MSW) - ff_face = wxTheFontNameDirectory.GetScreenName(M_FONTDATA->m_family, M_FONTDATA->m_weight, M_FONTDATA->m_style); -#else - ff_face = M_FONTDATA->m_faceName; - if ( ff_face.IsNull() ) - ff_face = ""; -#endif + if ( lf.lfWeight >= 600 ) + return wxFONTWEIGHT_BOLD; -/* Always calculate fonts using the screen DC (is this the best strategy?) - * There may be confusion if a font is selected into a printer - * DC (say), because the height will be calculated very differently. - // What sort of display is it? - int technology = ::GetDeviceCaps(dc, TECHNOLOGY); + return wxFONTWEIGHT_NORMAL; +} - int nHeight; - - if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER) +bool wxNativeFontInfo::GetUnderlined() const +{ + return lf.lfUnderline != 0; +} + +wxString wxNativeFontInfo::GetFaceName() const +{ + return lf.lfFaceName; +} + +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + wxFontFamily family; + + // extract family from pitch-and-family + switch ( lf.lfPitchAndFamily & ~PITCH_MASK ) { - // Have to get screen DC Caps, because a metafile will return 0. - HDC dc2 = ::GetDC(NULL); - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72; - ::ReleaseDC(NULL, dc2); + case FF_ROMAN: + family = wxFONTFAMILY_ROMAN; + break; + + default: + wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") ); + // fall through + + case FF_SWISS: + family = wxFONTFAMILY_SWISS; + break; + + case FF_SCRIPT: + family = wxFONTFAMILY_SCRIPT; + break; + + case FF_MODERN: + family = wxFONTFAMILY_MODERN; + break; + + case FF_DECORATIVE: + family = wxFONTFAMILY_DECORATIVE; + break; } - else + + return family; +} + +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxGetFontEncFromCharSet(lf.lfCharSet); +} + +void wxNativeFontInfo::SetPointSize(int pointsize) +{ + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); + + lf.lfHeight = -(int)((pointsize*((double)ppInch)/72.0) + 0.5); +} + +void wxNativeFontInfo::SetPixelSize(const wxSize& pixelSize) +{ + lf.lfHeight = pixelSize.GetHeight(); + lf.lfWidth = pixelSize.GetWidth(); +} + + +void wxNativeFontInfo::SetStyle(wxFontStyle style) +{ + switch ( style ) { - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72; - } -*/ - // Have to get screen DC Caps, because a metafile will return 0. - HDC dc2 = ::GetDC(NULL); - int ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY); - ::ReleaseDC(NULL, dc2); - - // New behaviour: apparently ppInch varies according to - // Large/Small Fonts setting in Windows. This messes - // up fonts. So, set ppInch to a constant 96 dpi. - ppInch = 96; - -#if FONT_SIZE_COMPATIBILITY - // Incorrect, but compatible with old wxWindows behaviour - int nHeight = (M_FONTDATA->m_pointSize*ppInch/72); -#else - // Correct for Windows compatibility - int nHeight = - (M_FONTDATA->m_pointSize*ppInch/72); -#endif + default: + wxFAIL_MSG( _T("unknown font style") ); + // fall through - bool ff_underline = M_FONTDATA->m_underlined; + case wxFONTSTYLE_NORMAL: + lf.lfItalic = FALSE; + break; - M_FONTDATA->m_hFont = (WXHFONT) CreateFont(nHeight, 0, 0, 0,ff_weight,ff_italic,(BYTE)ff_underline, - 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, - PROOF_QUALITY, DEFAULT_PITCH | ff_family, (ff_face == "" ? NULL : (const char *)ff_face)); -#ifdef DEBUG_CREATE - if (m_hFont==NULL) wxError("Cannot create font","Internal Error") ; -#endif - return (M_FONTDATA->m_hFont != (WXHFONT) NULL); - } - return FALSE; + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + lf.lfItalic = TRUE; + break; + } } -bool wxFont::FreeResource(bool force) +void wxNativeFontInfo::SetWeight(wxFontWeight weight) { - if (M_FONTDATA && M_FONTDATA->m_hFont) - { - ::DeleteObject((HFONT) M_FONTDATA->m_hFont); - M_FONTDATA->m_hFont = 0; - return TRUE; - } - return FALSE; + switch ( weight ) + { + default: + wxFAIL_MSG( _T("unknown font weight") ); + // fall through + + case wxFONTWEIGHT_NORMAL: + lf.lfWeight = FW_NORMAL; + break; + + case wxFONTWEIGHT_LIGHT: + lf.lfWeight = FW_LIGHT; + break; + + case wxFONTWEIGHT_BOLD: + lf.lfWeight = FW_BOLD; + break; + } } -/* -bool wxFont::UseResource(void) +void wxNativeFontInfo::SetUnderlined(bool underlined) { - IncrementResourceUsage(); - return TRUE; + lf.lfUnderline = underlined; } -bool wxFont::ReleaseResource(void) +void wxNativeFontInfo::SetFaceName(const wxString& facename) { - DecrementResourceUsage(); - return TRUE; + wxStrncpy(lf.lfFaceName, facename, WXSIZEOF(lf.lfFaceName)); } -*/ - -WXHANDLE wxFont::GetResourceHandle(void) + +void wxNativeFontInfo::SetFamily(wxFontFamily family) { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont ; + BYTE ff_family; + wxString facename; + + switch ( family ) + { + case wxSCRIPT: + ff_family = FF_SCRIPT; + facename = _T("Script"); + break; + + case wxDECORATIVE: + ff_family = FF_DECORATIVE; + facename = _T("Old English Text MT"); + break; + + case wxROMAN: + ff_family = FF_ROMAN; + facename = _T("Times New Roman"); + break; + + case wxTELETYPE: + case wxMODERN: + ff_family = FF_MODERN; + facename = _T("Courier New"); + break; + + case wxSWISS: + ff_family = FF_SWISS; + facename = _T("Arial"); + break; + + case wxDEFAULT: + default: + { + // We want Windows 2000 or later to have new fonts even MS Shell Dlg + // is returned as default GUI font for compatibility + int verMaj; + ff_family = FF_SWISS; + if(wxGetOsVersion(&verMaj) == wxWINDOWS_NT && verMaj >= 5) + facename = _T("MS Shell Dlg 2"); + else + facename = _T("MS Shell Dlg"); + } + } + + lf.lfPitchAndFamily = (BYTE)(DEFAULT_PITCH) | ff_family; + + if ( !wxStrlen(lf.lfFaceName) ) + { + SetFaceName(facename); + } } -bool wxFont::IsFree(void) +void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) { - return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); + wxNativeEncodingInfo info; + if ( !wxGetNativeFontEncoding(encoding, &info) ) + { +#if wxUSE_FONTMAP + if ( wxFontMapper::Get()->GetAltForEncoding(encoding, &info) ) + { + if ( !info.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(info.facename); + } + } + else +#endif // wxUSE_FONTMAP + { + // unsupported encoding, replace with the default + info.charset = DEFAULT_CHARSET; + } + } + + lf.lfCharSet = (BYTE)info.charset; } -void wxFont::SetPointSize(int pointSize) +bool wxNativeFontInfo::FromString(const wxString& s) +{ + long l; + + wxStringTokenizer tokenizer(s, _T(";")); + + // first the version + wxString token = tokenizer.GetNextToken(); + if ( token != _T('0') ) + return false; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfHeight = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfWidth = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfEscapement = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfOrientation = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfWeight = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfItalic = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfUnderline = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfStrikeOut = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfCharSet = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfOutPrecision = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfClipPrecision = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfQuality = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return false; + lf.lfPitchAndFamily = (BYTE)l; + + token = tokenizer.GetNextToken(); + if(!token) + return false; + wxStrcpy(lf.lfFaceName, token.c_str()); + + return true; +} + +wxString wxNativeFontInfo::ToString() const +{ + wxString s; + + s.Printf(_T("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"), + 0, // version, in case we want to change the format later + lf.lfHeight, + lf.lfWidth, + lf.lfEscapement, + lf.lfOrientation, + lf.lfWeight, + lf.lfItalic, + lf.lfUnderline, + lf.lfStrikeOut, + lf.lfCharSet, + lf.lfOutPrecision, + lf.lfClipPrecision, + lf.lfQuality, + lf.lfPitchAndFamily, + lf.lfFaceName); + + return s; +} + +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- + +void wxFont::Init() { +} + +bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) +{ + UnRef(); + + m_refData = new wxFontRefData(info, hFont); + + RealizeResource(); + + return true; +} + +wxFont::wxFont(const wxString& fontdesc) +{ + wxNativeFontInfo info; + if ( info.FromString(fontdesc) ) + (void)Create(info); +} + +/* Constructor for a font. Note that the real construction is done + * in wxDC::SetFont, when information is available about scaling etc. + */ +bool wxFont::DoCreate(int pointSize, + const wxSize& pixelSize, + bool sizeUsingPixels, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) +{ + 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 ( pointSize == wxDEFAULT ) + { + pointSize = wxNORMAL_FONT->GetPointSize(); + } + + m_refData = new wxFontRefData(pointSize, pixelSize, sizeUsingPixels, + family, style, weight, + underlined, faceName, encoding); + + RealizeResource(); + + return true; +} + +wxFont::~wxFont() +{ +} + +// ---------------------------------------------------------------------------- +// real implementation +// ---------------------------------------------------------------------------- + +bool 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 + return true; + } + + return M_FONTDATA->Alloc(this); +} + +bool wxFont::FreeResource(bool WXUNUSED(force)) +{ + if ( GetResourceHandle() ) + { + M_FONTDATA->Free(); + + return true; + } + + return false; +} + +WXHANDLE wxFont::GetResourceHandle() const +{ + return (WXHANDLE)GetHFONT(); +} + +WXHFONT wxFont::GetHFONT() const +{ + return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0; +} + +bool wxFont::IsFree() const +{ + return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0); +} + +void wxFont::Unshare() +{ + // Don't change shared data if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_pointSize = pointSize; + { + m_refData = new wxFontRefData(); + } + else + { + wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); + UnRef(); + m_refData = ref; + } +} + +// ---------------------------------------------------------------------------- +// change font attribute: we recreate font when doing it +// ---------------------------------------------------------------------------- + +void wxFont::SetPointSize(int pointSize) +{ + Unshare(); + + M_FONTDATA->SetPointSize(pointSize); + + RealizeResource(); +} + +void wxFont::SetPixelSize(const wxSize& pixelSize) +{ + Unshare(); + + M_FONTDATA->SetPixelSize(pixelSize); + + RealizeResource(); } void wxFont::SetFamily(int family) { - if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_family = family; + Unshare(); + + M_FONTDATA->SetFamily(family); + + RealizeResource(); } void wxFont::SetStyle(int style) { - if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_style = style; + Unshare(); + + M_FONTDATA->SetStyle(style); + + RealizeResource(); } void wxFont::SetWeight(int weight) { - if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_weight = weight; + Unshare(); + + M_FONTDATA->SetWeight(weight); + + RealizeResource(); } void wxFont::SetFaceName(const wxString& faceName) { - if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_faceName = faceName; + Unshare(); + + M_FONTDATA->SetFaceName(faceName); + + RealizeResource(); } void wxFont::SetUnderlined(bool underlined) { - if ( !m_refData ) - m_refData = new wxFontRefData; - M_FONTDATA->m_underlined = underlined; -} - -wxString wxFont::GetFamilyString(void) 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; -} - -/* New font system */ -wxString wxFont::GetFaceName(void) const -{ - wxString str(""); - if (M_FONTDATA) - str = M_FONTDATA->m_faceName ; - return str; -} - -wxString wxFont::GetStyleString(void) const -{ - wxString styl(""); - switch (GetStyle()) - { - case wxITALIC: - styl = "wxITALIC"; - break; - case wxSLANT: - styl = "wxSLANT"; - break; - default: - styl = "wxNORMAL"; - break; - } - return styl; -} - -wxString wxFont::GetWeightString(void) const -{ - wxString w(""); - switch (GetWeight()) - { - case wxBOLD: - w = "wxBOLD"; - break; - case wxLIGHT: - w = "wxLIGHT"; - break; - default: - w = "wxNORMAL"; - break; - } - return w; + Unshare(); + + M_FONTDATA->SetUnderlined(underlined); + + RealizeResource(); +} + +void wxFont::SetEncoding(wxFontEncoding encoding) +{ + Unshare(); + + M_FONTDATA->SetEncoding(encoding); + + RealizeResource(); +} + +void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info) +{ + Unshare(); + + FreeResource(); + + *M_FONTDATA = wxFontRefData(info); + + RealizeResource(); +} + +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- + +int wxFont::GetPointSize() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetPointSize(); +} + +wxSize wxFont::GetPixelSize() const +{ + return M_FONTDATA->GetPixelSize(); +} + +bool wxFont::IsUsingSizeInPixels() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->IsUsingSizeInPixels(); +} + +int wxFont::GetFamily() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetFamily(); +} + +int wxFont::GetStyle() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetStyle(); +} + +int wxFont::GetWeight() const +{ + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetWeight(); +} + +bool wxFont::GetUnderlined() const +{ + wxCHECK_MSG( Ok(), false, wxT("invalid font") ); + + return M_FONTDATA->GetUnderlined(); +} + +wxString wxFont::GetFaceName() const +{ + wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") ); + + return M_FONTDATA->GetFaceName(); +} + +wxFontEncoding wxFont::GetEncoding() const +{ + wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + + return M_FONTDATA->GetEncoding(); +} + +const wxNativeFontInfo *wxFont::GetNativeFontInfo() const +{ + return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo()) + : NULL; +} + +bool wxFont::IsFixedWidth() const +{ + if ( M_FONTDATA->HasNativeFontInfo() ) + { + // the two low-order bits specify the pitch of the font, the rest is + // family + BYTE pitch = + (BYTE)(M_FONTDATA->GetNativeFontInfo().lf.lfPitchAndFamily & PITCH_MASK); + + return pitch == FIXED_PITCH; + } + + return wxFontBase::IsFixedWidth(); }