Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5a6b7681d86d369811efb0c88a0b1db0e85ae579
wxWidgets/src/common/fontcmn.cpp
Vadim Zeitlin 5a6b7681d8 Refactor float to int point size conversions once again 
They will be also needed in wxFontInfo soon, so move them there and use
these functions from both wxFont and wxNativeFontInfo, as they can
depend on wxFontInfo but not the other way round.

No real changes.
2018-09-17 15:24:40 +02:00

1356 lines
38 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// Name: src/common/fontcmn.cpp
// Purpose: implementation of wxFontBase methods
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/font.h"
#ifndef WX_PRECOMP
#include "wx/dc.h"
#include "wx/intl.h"
#include "wx/dcscreen.h"
#include "wx/log.h"
#include "wx/gdicmn.h"
#endif // WX_PRECOMP
#if defined(__WXMSW__)
#include "wx/msw/private.h" // includes windows.h for LOGFONT
#include "wx/msw/winundef.h"
#endif
#include "wx/fontutil.h" // for wxNativeFontInfo
#include "wx/fontmap.h"
#include "wx/fontenum.h"
#include "wx/tokenzr.h"
// debugger helper: this function can be called from a debugger to show what
// the date really is
extern const char *wxDumpFont(const wxFont *font)
{
static char buf[256];
const wxFontWeight weight = font->GetWeight();
wxString s;
s.Printf(wxS("%s-%s-%s-%d-%d"),
font->GetFaceName(),
weight == wxFONTWEIGHT_NORMAL
? wxT("normal")
: weight == wxFONTWEIGHT_BOLD
? wxT("bold")
: wxT("light"),
font->GetStyle() == wxFONTSTYLE_NORMAL
? wxT("regular")
: wxT("italic"),
font->GetPointSize(),
font->GetEncoding());
wxStrlcpy(buf, s.mb_str(), WXSIZEOF(buf));
return buf;
}
// ----------------------------------------------------------------------------
// XTI
// ----------------------------------------------------------------------------
wxBEGIN_ENUM( wxFontFamily )
wxENUM_MEMBER( wxFONTFAMILY_DEFAULT )
wxENUM_MEMBER( wxFONTFAMILY_DECORATIVE )
wxENUM_MEMBER( wxFONTFAMILY_ROMAN )
wxENUM_MEMBER( wxFONTFAMILY_SCRIPT )
wxENUM_MEMBER( wxFONTFAMILY_SWISS )
wxENUM_MEMBER( wxFONTFAMILY_MODERN )
wxENUM_MEMBER( wxFONTFAMILY_TELETYPE )
wxEND_ENUM( wxFontFamily )
wxBEGIN_ENUM( wxFontStyle )
wxENUM_MEMBER( wxFONTSTYLE_NORMAL )
wxENUM_MEMBER( wxFONTSTYLE_ITALIC )
wxENUM_MEMBER( wxFONTSTYLE_SLANT )
wxEND_ENUM( wxFontStyle )
wxBEGIN_ENUM( wxFontWeight )
wxENUM_MEMBER( wxFONTWEIGHT_THIN )
wxENUM_MEMBER( wxFONTWEIGHT_EXTRALIGHT )
wxENUM_MEMBER( wxFONTWEIGHT_LIGHT )
wxENUM_MEMBER( wxFONTWEIGHT_NORMAL )
wxENUM_MEMBER( wxFONTWEIGHT_MEDIUM )
wxENUM_MEMBER( wxFONTWEIGHT_SEMIBOLD )
wxENUM_MEMBER( wxFONTWEIGHT_BOLD )
wxENUM_MEMBER( wxFONTWEIGHT_EXTRABOLD )
wxENUM_MEMBER( wxFONTWEIGHT_HEAVY )
wxENUM_MEMBER( wxFONTWEIGHT_EXTRAHEAVY )
wxEND_ENUM( wxFontWeight )
wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont, wxGDIObject, "wx/font.h");
//WX_IMPLEMENT_ANY_VALUE_TYPE(wxAnyValueTypeImpl<wxFont>)
wxBEGIN_PROPERTIES_TABLE(wxFont)
wxPROPERTY( Size,int, SetPointSize, GetPointSize, 12, 0 /*flags*/, \
wxT("Helpstring"), wxT("group"))
wxPROPERTY( Family, wxFontFamily , SetFamily, GetFamily, (wxFontFamily)wxDEFAULT, \
0 /*flags*/, wxT("Helpstring"), wxT("group")) // wxFontFamily
wxPROPERTY( Style, wxFontStyle, SetStyle, GetStyle, (wxFontStyle)wxNORMAL, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // wxFontStyle
wxPROPERTY( Weight, wxFontWeight, SetWeight, GetWeight, (wxFontWeight)wxNORMAL, 0 /*flags*/, \
wxT("Helpstring"), wxT("group")) // wxFontWeight
wxPROPERTY( Underlined, bool, SetUnderlined, GetUnderlined, false, 0 /*flags*/, \
wxT("Helpstring"), wxT("group"))
wxPROPERTY( Strikethrough, bool, SetStrikethrough, GetStrikethrough, false, 0, \
wxT("Helpstring"), wxT("group"))
wxPROPERTY( Face, wxString, SetFaceName, GetFaceName, wxEMPTY_PARAMETER_VALUE, \
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, wxFontFamily, Family, wxFontStyle, Style, wxFontWeight, Weight, \
bool, Underlined, wxString, Face )
wxEMPTY_HANDLERS_TABLE(wxFont)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontBase
// ----------------------------------------------------------------------------
wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
/* static */
void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding)
{
// GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
// and, besides, using this value here doesn't make any sense
wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,
wxT("can't set default encoding to wxFONTENCODING_DEFAULT") );
ms_encodingDefault = encoding;
}
wxFontBase::~wxFontBase()
{
// this destructor is required for Darwin
}
/* static */
wxFont *wxFontBase::New(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding)
{
return new wxFont(size, family, style, weight, underlined, face, encoding);
}
/* static */
wxFont *wxFontBase::New(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding)
{
return new wxFont(pixelSize, family, style, weight, underlined,
face, encoding);
}
/* static */
wxFont *wxFontBase::New(int pointSize,
wxFontFamily family,
int flags,
const wxString& face,
wxFontEncoding encoding)
{
return New(pointSize, family,
GetStyleFromFlags(flags),
GetWeightFromFlags(flags),
GetUnderlinedFromFlags(flags),
face, encoding);
}
/* static */
wxFont *wxFontBase::New(const wxSize& pixelSize,
wxFontFamily family,
int flags,
const wxString& face,
wxFontEncoding encoding)
{
return New(pixelSize, family,
GetStyleFromFlags(flags),
GetWeightFromFlags(flags),
GetUnderlinedFromFlags(flags),
face, encoding);
}
/* static */
wxFont *wxFontBase::New(const wxNativeFontInfo& info)
{
return new wxFont(info);
}
/* static */
wxFont *wxFontBase::New(const wxString& strNativeFontDesc)
{
wxNativeFontInfo fontInfo;
if ( !fontInfo.FromString(strNativeFontDesc) )
return new wxFont(*wxNORMAL_FONT);
return New(fontInfo);
}
bool wxFontBase::IsFixedWidth() const
{
return GetFamily() == wxFONTFAMILY_TELETYPE;
}
// Convert to/from wxFontWeight enum elements and numeric weight values.
// This function interprets wxNORMAL, wxLIGHT and wxBOLD values in addition to
// the actual wxFontWeight enum element values for compatibility. It does check
// that it gets either the one or the other.
/* static */
int wxFontBase::GetNumericWeightOf(wxFontWeight weight)
{
// deal with compatibility constants
if (weight >= 90 && weight <= 92)
{
if (weight == 90 /* wxNORMAL */)
weight = wxFONTWEIGHT_NORMAL;
else if (weight == 91 /* wxLIGHT */)
weight = wxFONTWEIGHT_LIGHT;
else if (weight == 92 /* wxBOLD */)
weight = wxFONTWEIGHT_BOLD;
}
wxASSERT(weight > wxFONTWEIGHT_INVALID);
wxASSERT(weight <= wxFONTWEIGHT_MAX);
wxASSERT(weight % 100 == 0);
return weight;
}
// As its name indicates, this function returns the closest wxFontWeight enum
// element, even if its value doesn't correspond to the given weight exactly.
/* static */
wxFontWeight wxFontBase::GetWeightClosestToNumericValue(int numWeight)
{
wxASSERT(numWeight > 0);
wxASSERT(numWeight <= 1000);
// round to nearest hundredth = wxFONTWEIGHT_ constant
int weight = ((numWeight + 50) / 100) * 100;
if (weight < wxFONTWEIGHT_THIN)
weight = wxFONTWEIGHT_THIN;
if (weight > wxFONTWEIGHT_MAX)
weight = wxFONTWEIGHT_MAX;
return static_cast<wxFontWeight>(weight);
}
int wxFontBase::GetPointSize() const
{
return wxFontInfo::ToIntPointSize(GetFractionalPointSize());
}
wxSize wxFontBase::GetPixelSize() const
{
wxScreenDC dc;
dc.SetFont(*(wxFont *)this);
return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
}
wxFontWeight wxFontBase::GetWeight() const
{
wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, "invalid font" );
return GetWeightClosestToNumericValue(GetNumericWeight());
}
bool wxFontBase::IsUsingSizeInPixels() const
{
return false;
}
void wxFontBase::SetPointSize(int pointSize)
{
SetFractionalPointSize(wxFontInfo::ToFloatPointSize(pointSize));
}
void wxFontBase::SetPixelSize( const wxSize& pixelSize )
{
wxCHECK_RET( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0,
"Negative values for the pixel size or zero pixel height are not allowed" );
wxScreenDC dc;
// NOTE: this algorithm for adjusting the font size is used by all
// implementations of wxFont except under wxMSW and wxGTK where
// native support to font creation using pixel-size is provided.
int largestGood = 0;
int smallestBad = 0;
bool initialGoodFound = false;
bool initialBadFound = false;
// NB: this assignment was separated from the variable definition
// in order to fix a gcc v3.3.3 compiler crash
int currentSize = GetPointSize();
while (currentSize > 0)
{
dc.SetFont(*static_cast<wxFont*>(this));
// if currentSize (in points) results in a font that is smaller
// than required by pixelSize it is considered a good size
// NOTE: the pixel size width may be zero
if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
(pixelSize.GetWidth() == 0 ||
dc.GetCharWidth() <= pixelSize.GetWidth()))
{
largestGood = currentSize;
initialGoodFound = true;
}
else
{
smallestBad = currentSize;
initialBadFound = true;
}
if (!initialGoodFound)
{
currentSize /= 2;
}
else if (!initialBadFound)
{
currentSize *= 2;
}
else
{
int distance = smallestBad - largestGood;
if (distance == 1)
break;
currentSize = largestGood + distance / 2;
}
SetPointSize(currentSize);
}
if (currentSize != largestGood)
SetPointSize(largestGood);
}
void wxFontBase::SetWeight(wxFontWeight weight)
{
SetNumericWeight(GetNumericWeightOf(weight));
}
void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
{
#ifdef wxNO_NATIVE_FONTINFO
SetFractionalPointSize(info.pointSize);
SetFamily(info.family);
SetStyle(info.style);
SetNumericWeight(info.weight);
SetUnderlined(info.underlined);
SetStrikethrough(info.strikethrough);
SetFaceName(info.faceName);
SetEncoding(info.encoding);
#else
(void)info;
#endif
}
wxString wxFontBase::GetNativeFontInfoDesc() const
{
wxString fontDesc;
wxCHECK_MSG(IsOk(), fontDesc, "invalid font");
const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
if ( fontInfo )
{
fontDesc = fontInfo->ToString();
wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
}
else
{
wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
}
return fontDesc;
}
wxString wxFontBase::GetNativeFontInfoUserDesc() const
{
wxString fontDesc;
wxCHECK_MSG(IsOk(), fontDesc, "invalid font");
const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
if ( fontInfo )
{
fontDesc = fontInfo->ToUserString();
wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
}
else
{
wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
}
return fontDesc;
}
bool wxFontBase::SetNativeFontInfo(const wxString& info)
{
wxNativeFontInfo fontInfo;
if ( !info.empty() && fontInfo.FromString(info) )
{
SetNativeFontInfo(fontInfo);
return true;
}
return false;
}
bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
{
wxNativeFontInfo fontInfo;
if ( !info.empty() && fontInfo.FromUserString(info) )
{
SetNativeFontInfo(fontInfo);
return true;
}
return false;
}
bool wxFontBase::operator==(const wxFont& font) const
{
// either it is the same font, i.e. they share the same common data or they
// have different ref datas but still describe the same font
return IsSameAs(font) ||
(
IsOk() == font.IsOk() &&
GetPointSize() == font.GetPointSize() &&
// in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
// operator==() resulting in infinite recursion so we can't use it
// in that port
// in wxQT, GetPixelSize is too slow to be used here
#if (!defined(__WXGTK__) || defined(__WXGTK20__)) && !defined(__WXQT__)
GetPixelSize() == font.GetPixelSize() &&
#endif
GetFamily() == font.GetFamily() &&
GetStyle() == font.GetStyle() &&
GetWeight() == font.GetWeight() &&
GetUnderlined() == font.GetUnderlined() &&
GetStrikethrough() == font.GetStrikethrough() &&
GetFaceName().IsSameAs(font.GetFaceName(), false) &&
GetEncoding() == font.GetEncoding()
);
}
wxFontFamily wxFontBase::GetFamily() const
{
wxCHECK_MSG( IsOk(), wxFONTFAMILY_UNKNOWN, wxS("invalid font") );
// Don't return wxFONTFAMILY_UNKNOWN from here because it prevents the code
// like wxFont(size, wxNORMAL_FONT->GetFamily(), ...) from working (see
// #12330). This is really just a hack but it allows to keep compatibility
// and doesn't really have any bad drawbacks so do this until someone comes
// up with a better idea.
const wxFontFamily family = DoGetFamily();
return family == wxFONTFAMILY_UNKNOWN ? wxFONTFAMILY_DEFAULT : family;
}
wxString wxFontBase::GetFamilyString() const
{
wxCHECK_MSG( IsOk(), "wxFONTFAMILY_DEFAULT", "invalid font" );
switch ( GetFamily() )
{
case wxFONTFAMILY_DECORATIVE: return "wxFONTFAMILY_DECORATIVE";
case wxFONTFAMILY_ROMAN: return "wxFONTFAMILY_ROMAN";
case wxFONTFAMILY_SCRIPT: return "wxFONTFAMILY_SCRIPT";
case wxFONTFAMILY_SWISS: return "wxFONTFAMILY_SWISS";
case wxFONTFAMILY_MODERN: return "wxFONTFAMILY_MODERN";
case wxFONTFAMILY_TELETYPE: return "wxFONTFAMILY_TELETYPE";
case wxFONTFAMILY_UNKNOWN: return "wxFONTFAMILY_UNKNOWN";
default: return "wxFONTFAMILY_DEFAULT";
}
}
wxString wxFontBase::GetStyleString() const
{
wxCHECK_MSG( IsOk(), "wxFONTSTYLE_DEFAULT", "invalid font" );
switch ( GetStyle() )
{
case wxFONTSTYLE_NORMAL: return "wxFONTSTYLE_NORMAL";
case wxFONTSTYLE_SLANT: return "wxFONTSTYLE_SLANT";
case wxFONTSTYLE_ITALIC: return "wxFONTSTYLE_ITALIC";
default: return "wxFONTSTYLE_DEFAULT";
}
}
wxString wxFontBase::GetWeightString() const
{
wxCHECK_MSG( IsOk(), "wxFONTWEIGHT_DEFAULT", "invalid font" );
switch ( GetWeight() )
{
case wxFONTWEIGHT_THIN: return "wxFONTWEIGHT_THIN";
case wxFONTWEIGHT_EXTRALIGHT: return "wxFONTWEIGHT_EXTRALIGHT";
case wxFONTWEIGHT_LIGHT: return "wxFONTWEIGHT_LIGHT";
case wxFONTWEIGHT_NORMAL: return "wxFONTWEIGHT_NORMAL";
case wxFONTWEIGHT_MEDIUM: return "wxFONTWEIGHT_MEDIUM";
case wxFONTWEIGHT_SEMIBOLD: return "wxFONTWEIGHT_SEMIBOLD";
case wxFONTWEIGHT_BOLD: return "wxFONTWEIGHT_BOLD";
case wxFONTWEIGHT_EXTRABOLD: return "wxFONTWEIGHT_EXTRABOLD";
case wxFONTWEIGHT_HEAVY: return "wxFONTWEIGHT_HEAVY";
case wxFONTWEIGHT_EXTRAHEAVY: return "wxFONTWEIGHT_EXTRAHEAVY";
default: return "wxFONTWEIGHT_DEFAULT";
}
}
bool wxFontBase::SetFaceName(const wxString& facename)
{
#if wxUSE_FONTENUM
if (!wxFontEnumerator::IsValidFacename(facename))
{
UnRef(); // make IsOk() return false
return false;
}
#else // !wxUSE_FONTENUM
wxUnusedVar(facename);
#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
return true;
}
/* static */
void wxFontBase::AccountForCompatValues(int& pointSize,
wxFontStyle& style,
wxFontWeight& weight)
{
// Old code specifies wxDEFAULT instead of -1 or wxNORMAL instead of the
// new type-safe wxFONTSTYLE_NORMAL or wxFONTWEIGHT_NORMAL, continue
// handling this for compatibility.
if ( pointSize == wxDEFAULT )
pointSize = -1;
if ( static_cast<int>(style) == wxDEFAULT )
style = wxFONTSTYLE_NORMAL;
if ( static_cast<int>(weight) == wxDEFAULT )
weight = wxFONTWEIGHT_NORMAL;
}
void wxFontBase::SetSymbolicSize(wxFontSymbolicSize size)
{
SetSymbolicSizeRelativeTo(size, wxNORMAL_FONT->GetPointSize());
}
/* static */
int wxFontBase::AdjustToSymbolicSize(wxFontSymbolicSize size, int base)
{
// Using a fixed factor (1.2, from CSS2) is a bad idea as explained at
// http://www.w3.org/TR/CSS21/fonts.html#font-size-props so use the values
// from http://style.cleverchimp.com/font_size_intervals/altintervals.html
// instead.
static const float factors[] = { 0.60f, 0.75f, 0.89f, 1.f, 1.2f, 1.5f, 2.f };
wxCOMPILE_TIME_ASSERT
(
WXSIZEOF(factors) == wxFONTSIZE_XX_LARGE - wxFONTSIZE_XX_SMALL + 1,
WrongFontSizeFactorsSize
);
return wxRound(factors[size - wxFONTSIZE_XX_SMALL]*base);
}
wxFont& wxFont::MakeBold()
{
SetWeight(wxFONTWEIGHT_BOLD);
return *this;
}
wxFont wxFont::Bold() const
{
wxFont font(*this);
font.MakeBold();
return font;
}
wxFont wxFont::GetBaseFont() const
{
wxFont font(*this);
font.SetStyle(wxFONTSTYLE_NORMAL);
font.SetWeight(wxFONTWEIGHT_NORMAL );
font.SetUnderlined(false);
font.SetStrikethrough(false);
return font;
}
wxFont& wxFont::MakeItalic()
{
SetStyle(wxFONTSTYLE_ITALIC);
return *this;
}
wxFont wxFont::Italic() const
{
wxFont font(*this);
font.MakeItalic();
return font;
}
wxFont& wxFont::MakeUnderlined()
{
SetUnderlined(true);
return *this;
}
wxFont wxFont::Underlined() const
{
wxFont font(*this);
font.MakeUnderlined();
return font;
}
wxFont wxFont::Strikethrough() const
{
wxFont font(*this);
font.MakeStrikethrough();
return font;
}
wxFont& wxFont::MakeStrikethrough()
{
SetStrikethrough(true);
return *this;
}
wxFont& wxFont::Scale(float x)
{
SetPointSize(int(x*GetPointSize() + 0.5));
return *this;
}
wxFont wxFont::Scaled(float x) const
{
wxFont font(*this);
font.Scale(x);
return font;
}
// ----------------------------------------------------------------------------
// wxNativeFontInfo
// ----------------------------------------------------------------------------
// Up to now, there are no native implementations of this function:
void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
{
#if wxUSE_FONTENUM
for (size_t i=0; i < facenames.GetCount(); i++)
{
if (wxFontEnumerator::IsValidFacename(facenames[i]))
{
SetFaceName(facenames[i]);
return;
}
}
// set the first valid facename we can find on this system
wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
SetFaceName(validfacename);
#else // !wxUSE_FONTENUM
SetFaceName(facenames[0]);
#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
}
int wxNativeFontInfo::GetPointSize() const
{
return wxFontInfo::ToIntPointSize(GetFractionalPointSize());
}
void wxNativeFontInfo::SetPointSize(int pointsize)
{
SetFractionalPointSize(wxFontInfo::ToFloatPointSize(pointsize));
}
#ifdef wxNO_NATIVE_FONTINFO
// These are the generic forms of FromString()/ToString.
//
// convert to/from the string representation: the general format is
// "version;the rest..." with currently defined versions being:
//
// 0;pointsize;family;style;weight;underlined;facename;encoding
// 1;pointsize;family;style;weight;underlined;strikethrough;facename;encoding
bool wxNativeFontInfo::FromString(const wxString& s)
{
long l;
unsigned long version;
wxStringTokenizer tokenizer(s, wxT(";"));
wxString token = tokenizer.GetNextToken();
if ( !token.ToULong(&version) || version > 1 )
return false;
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
pointSize = (int)l;
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
family = (wxFontFamily)l;
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
style = (wxFontStyle)l;
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
weight = (wxFontWeight)l;
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
underlined = l != 0;
if ( version == 1 )
{
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
strikethrough = l != 0;
}
faceName = tokenizer.GetNextToken();
#ifndef __WXMAC__
if( !faceName )
return false;
#endif
token = tokenizer.GetNextToken();
if ( !token.ToLong(&l) )
return false;
encoding = (wxFontEncoding)l;
return true;
}
wxString wxNativeFontInfo::ToString() const
{
wxString s;
s.Printf(wxT("%d;%d;%d;%d;%d;%d;%d;%s;%d"),
1, // version
GetPointSize(),
family,
(int)style,
(int)weight,
underlined,
strikethrough,
faceName.GetData(),
(int)encoding);
return s;
}
void wxNativeFontInfo::Init()
{
pointSize = 0.0f;
family = wxFONTFAMILY_DEFAULT;
style = wxFONTSTYLE_NORMAL;
weight = wxFONTWEIGHT_NORMAL;
underlined = false;
strikethrough = false;
faceName.clear();
encoding = wxFONTENCODING_DEFAULT;
}
float wxNativeFontInfo::GetFractionalPointSize() const
{
return pointSize;
}
wxFontStyle wxNativeFontInfo::GetStyle() const
{
return style;
}
int wxNativeFontInfo::GetNumericWeight() const
{
return weight;
}
bool wxNativeFontInfo::GetUnderlined() const
{
return underlined;
}
bool wxNativeFontInfo::GetStrikethrough() const
{
return strikethrough;
}
wxString wxNativeFontInfo::GetFaceName() const
{
return faceName;
}
wxFontFamily wxNativeFontInfo::GetFamily() const
{
return family;
}
wxFontEncoding wxNativeFontInfo::GetEncoding() const
{
return encoding;
}
void wxNativeFontInfo::SetFractionalPointSize(float pointsize)
{
pointSize = pointsize;
}
void wxNativeFontInfo::SetStyle(wxFontStyle style_)
{
style = style_;
}
void wxNativeFontInfo::SetNumericWeight(int weight_)
{
weight = weight_;
}
void wxNativeFontInfo::SetUnderlined(bool underlined_)
{
underlined = underlined_;
}
void wxNativeFontInfo::SetStrikethrough(bool strikethrough_)
{
strikethrough = strikethrough_;
}
bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
{
faceName = facename_;
return true;
}
void wxNativeFontInfo::SetFamily(wxFontFamily family_)
{
family = family_;
}
void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
{
encoding = encoding_;
}
#endif // generic wxNativeFontInfo implementation
// conversion to/from user-readable string: this is used in the generic
// versions and under MSW as well because there is no standard font description
// format there anyhow (but there is a well-defined standard for X11 fonts used
// by wxGTK and wxMotif)
#if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined(__WXOSX__)
wxString wxNativeFontInfo::ToUserString() const
{
wxString desc;
// first put the adjectives, if any - this is English-centric, of course,
// but what else can we do?
if ( GetUnderlined() )
{
desc << _("underlined");
}
if ( GetStrikethrough() )
{
desc << _(" strikethrough");
}
switch ( GetWeight() )
{
default:
wxFAIL_MSG( wxT("unknown font weight") );
wxFALLTHROUGH;
case wxFONTWEIGHT_NORMAL:
break;
case wxFONTWEIGHT_THIN:
desc << _(" thin");
break;
case wxFONTWEIGHT_EXTRALIGHT:
desc << _(" extra light");
break;
case wxFONTWEIGHT_LIGHT:
desc << _(" light");
break;
case wxFONTWEIGHT_MEDIUM:
desc << _(" medium");
break;
case wxFONTWEIGHT_SEMIBOLD:
desc << _(" semi bold");
break;
case wxFONTWEIGHT_BOLD:
desc << _(" bold");
break;
case wxFONTWEIGHT_EXTRABOLD:
desc << _(" extra bold");
break;
case wxFONTWEIGHT_HEAVY:
desc << _(" heavy");
break;
case wxFONTWEIGHT_EXTRAHEAVY:
desc << _(" extra heavy");
break;
}
switch ( GetStyle() )
{
default:
wxFAIL_MSG( wxT("unknown font style") );
wxFALLTHROUGH;
case wxFONTSTYLE_NORMAL:
break;
// we don't distinguish between the two for now anyhow...
case wxFONTSTYLE_ITALIC:
case wxFONTSTYLE_SLANT:
desc << _(" italic");
break;
}
wxString face = GetFaceName();
if ( !face.empty() )
{
if (face.Contains(' ') || face.Contains(';') || face.Contains(','))
{
face.Replace("'", "");
// eventually remove quote characters: most systems do not
// allow them in a facename anyway so this usually does nothing
// make it possible for FromUserString() function to understand
// that the different words which compose this facename are
// not different adjectives or other data but rather all parts
// of the facename
desc << wxT(" '") << face << wxT("'");
}
else
desc << wxT(' ') << face;
}
else // no face name specified
{
// use the family
wxString familyStr;
switch ( GetFamily() )
{
case wxFONTFAMILY_DECORATIVE:
familyStr = "decorative";
break;
case wxFONTFAMILY_ROMAN:
familyStr = "roman";
break;
case wxFONTFAMILY_SCRIPT:
familyStr = "script";
break;
case wxFONTFAMILY_SWISS:
familyStr = "swiss";
break;
case wxFONTFAMILY_MODERN:
familyStr = "modern";
break;
case wxFONTFAMILY_TELETYPE:
familyStr = "teletype";
break;
case wxFONTFAMILY_DEFAULT:
case wxFONTFAMILY_UNKNOWN:
break;
default:
wxFAIL_MSG( "unknown font family" );
}
if ( !familyStr.empty() )
desc << " '" << familyStr << " family'";
}
int size = GetPointSize();
if ( size != wxNORMAL_FONT->GetPointSize() )
{
desc << wxT(' ') << size;
}
#if wxUSE_FONTMAP
wxFontEncoding enc = GetEncoding();
if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
{
desc << wxT(' ') << wxFontMapper::GetEncodingName(enc);
}
#endif // wxUSE_FONTMAP
return desc.Strip(wxString::both).MakeLower();
}
bool wxNativeFontInfo::FromUserString(const wxString& s)
{
// reset to the default state
Init();
// ToUserString() will quote the facename if it contains spaces, commas
// or semicolons: we must be able to understand that quoted text is
// a single token:
wxString toparse(s);
// parse a more or less free form string
wxStringTokenizer tokenizer(toparse, wxT(";, "), wxTOKEN_STRTOK);
wxString face;
unsigned long size;
bool weightfound = false, pointsizefound = false;
#if wxUSE_FONTMAP
bool encodingfound = false;
#endif
bool insideQuotes = false;
bool extraQualifierFound = false;
bool semiQualifierFound = false;
while ( tokenizer.HasMoreTokens() )
{
wxString token = tokenizer.GetNextToken();
// normalize it
token.Trim(true).Trim(false).MakeLower();
if (insideQuotes)
{
if (token.StartsWith("'") ||
token.EndsWith("'"))
{
insideQuotes = false;
// add this last token to the facename:
face += " " + token;
// normalize facename:
face = face.Trim(true).Trim(false);
face.Replace("'", "");
continue;
}
}
else
{
if (token.StartsWith("'"))
insideQuotes = true;
}
// look for the known tokens
if ( insideQuotes )
{
// only the facename may be quoted:
face += " " + token;
continue;
}
if ( token == wxT("underlined") || token == _("underlined") )
{
SetUnderlined(true);
}
else if ( token == wxT("strikethrough") || token == _("strikethrough") )
{
SetStrikethrough(true);
}
else if ( token == wxT("underlinedstrikethrough") )
{
SetUnderlined(true);
SetStrikethrough(true);
}
else if ( token == wxS("thin") || token == _("thin") )
{
SetWeight(wxFONTWEIGHT_THIN);
weightfound = true;
}
else if ( token == wxS("extra") || token == wxS("ultra"))
{
extraQualifierFound = true;
}
else if ( token == wxS("semi") || token == wxS("demi") )
{
semiQualifierFound = true;
}
else if ( token == wxS("extralight") || token == _("extralight") )
{
SetWeight(wxFONTWEIGHT_EXTRALIGHT);
weightfound = true;
}
else if ( token == wxS("light") || token == _("light") )
{
if ( extraQualifierFound )
SetWeight(wxFONTWEIGHT_EXTRALIGHT);
else
SetWeight(wxFONTWEIGHT_LIGHT);
weightfound = true;
}
else if ( token == wxS("normal") || token == _("normal") )
{
SetWeight(wxFONTWEIGHT_NORMAL);
weightfound = true;
}
else if ( token == wxS("medium") || token == _("medium") )
{
SetWeight(wxFONTWEIGHT_MEDIUM);
weightfound = true;
}
else if ( token == wxS("semibold") || token == _("semibold") )
{
SetWeight(wxFONTWEIGHT_SEMIBOLD);
weightfound = true;
}
else if ( token == wxS("bold") || token == _("bold") )
{
if ( extraQualifierFound )
SetWeight(wxFONTWEIGHT_EXTRABOLD);
else if ( semiQualifierFound )
SetWeight(wxFONTWEIGHT_SEMIBOLD);
else
SetWeight(wxFONTWEIGHT_BOLD);
weightfound = true;
}
else if ( token == wxS("extrabold") || token == _("extrabold") )
{
SetWeight(wxFONTWEIGHT_EXTRABOLD);
weightfound = true;
}
else if ( token == wxS("semibold") || token == _("semibold") )
{
SetWeight(wxFONTWEIGHT_SEMIBOLD);
weightfound = true;
}
else if ( token == wxS("heavy") || token == _("heavy") )
{
if ( extraQualifierFound )
SetWeight(wxFONTWEIGHT_EXTRAHEAVY);
else
SetWeight(wxFONTWEIGHT_HEAVY);
weightfound = true;
}
else if ( token == wxS("extraheavy") || token == _("extraheavy") )
{
SetWeight(wxFONTWEIGHT_EXTRAHEAVY);
weightfound = true;
}
else if ( token == wxT("italic") || token == _("italic") )
{
SetStyle(wxFONTSTYLE_ITALIC);
}
else if ( token.ToULong(&size ) )
{
SetPointSize(size);
pointsizefound = true;
}
else
{
#if wxUSE_FONTMAP
// try to interpret this as an encoding
wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
if ( encoding != wxFONTENCODING_DEFAULT &&
encoding != wxFONTENCODING_SYSTEM ) // returned when the recognition failed
{
SetEncoding(encoding);
encodingfound = true;
}
else
{
#endif // wxUSE_FONTMAP
// assume it is the face name
if ( !face.empty() )
{
face += wxT(' ');
}
face += token;
// skip the code which resets face below
continue;
#if wxUSE_FONTMAP
}
#endif // wxUSE_FONTMAP
}
// if we had had the facename, we shouldn't continue appending tokens
// to it (i.e. "foo bold bar" shouldn't result in the facename "foo
// bar")
if ( !face.empty() )
{
wxString familyStr;
if ( face.EndsWith(" family", &familyStr) )
{
// it's not a facename but rather a font family
wxFontFamily family;
if ( familyStr == "decorative" )
family = wxFONTFAMILY_DECORATIVE;
else if ( familyStr == "roman" )
family = wxFONTFAMILY_ROMAN;
else if ( familyStr == "script" )
family = wxFONTFAMILY_SCRIPT;
else if ( familyStr == "swiss" )
family = wxFONTFAMILY_SWISS;
else if ( familyStr == "modern" )
family = wxFONTFAMILY_MODERN;
else if ( familyStr == "teletype" )
family = wxFONTFAMILY_TELETYPE;
else
return false;
SetFamily(family);
}
// NB: the check on the facename is implemented in wxFontBase::SetFaceName
// and not in wxNativeFontInfo::SetFaceName thus we need to explicitly
// call here wxFontEnumerator::IsValidFacename
else if (
#if wxUSE_FONTENUM
!wxFontEnumerator::IsValidFacename(face) ||
#endif // wxUSE_FONTENUM
!SetFaceName(face) )
{
SetFaceName(wxNORMAL_FONT->GetFaceName());
}
face.clear();
}
}
// we might not have flushed it inside the loop
if ( !face.empty() )
{
// NB: the check on the facename is implemented in wxFontBase::SetFaceName
// and not in wxNativeFontInfo::SetFaceName thus we need to explicitly
// call here wxFontEnumerator::IsValidFacename
if (
#if wxUSE_FONTENUM
!wxFontEnumerator::IsValidFacename(face) ||
#endif // wxUSE_FONTENUM
!SetFaceName(face) )
{
SetFaceName(wxNORMAL_FONT->GetFaceName());
}
}
// set point size to default value if size was not given
if ( !pointsizefound )
SetFractionalPointSize(wxNORMAL_FONT->GetFractionalPointSize());
// set font weight to default value if weight was not given
if ( !weightfound )
SetWeight(wxFONTWEIGHT_NORMAL);
#if wxUSE_FONTMAP
// set font encoding to default value if encoding was not given
if ( !encodingfound )
SetEncoding(wxFONTENCODING_SYSTEM);
#endif // wxUSE_FONTMAP
return true;
}
#endif // generic or wxMSW
// compatibility functions using old API implemented using numeric weight values
wxFontWeight wxNativeFontInfo::GetWeight() const
{
return wxFontBase::GetWeightClosestToNumericValue(GetNumericWeight());
}
void wxNativeFontInfo::SetWeight(wxFontWeight weight)
{
const int numWeight = wxFontBase::GetNumericWeightOf(weight);
if ( numWeight != GetNumericWeight() )
SetNumericWeight(numWeight);
}
// wxFont <-> wxString utilities, used by wxConfig
wxString wxToString(const wxFontBase& font)
{
return font.IsOk() ? font.GetNativeFontInfoDesc()
: wxString();
}
bool wxFromString(const wxString& str, wxFontBase *font)
{
wxCHECK_MSG( font, false, wxT("NULL output parameter") );
if ( str.empty() )
{
*font = wxNullFont;
return true;
}
return font->SetNativeFontInfo(str);
}
Reference in New Issue View Git Blame Copy Permalink