src/common/fontcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/fontcmn.cpp
// Purpose:     implementation of wxFontBase methods
// Author:      Vadim Zeitlin
// Modified by:
// Created:     20.09.99
// RCS-ID:      $Id$
// 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"

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------

static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
{
    int currentSize = 0;
    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
    currentSize = font.GetPointSize();
    while (currentSize > 0)
    {
        dc.SetFont(font);

        // if currentSize (in points) results in a font that is smaller
        // than required by pixelSize it is considered a good size
        if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
                (!pixelSize.GetWidth() ||
                 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;
        }

        font.SetPointSize(currentSize);
    }

    if (currentSize != largestGood)
        font.SetPointSize(largestGood);
}

// ----------------------------------------------------------------------------
// 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,
                 _T("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,
                        int family,
                        int style,
                        int weight,
                        bool underlined,
                        const wxString& face,
                        wxFontEncoding encoding)
{
    return new wxFont(size, family, style, weight, underlined, face, encoding);
}

static inline int flags2Style(int flags)
{
    return flags & wxFONTFLAG_ITALIC
                    ? wxFONTSTYLE_ITALIC
                    : flags & wxFONTFLAG_SLANT
                        ? wxFONTSTYLE_SLANT
                        : wxFONTSTYLE_NORMAL;
}

static inline int flags2Weight(int flags)
{
    return flags & wxFONTFLAG_LIGHT
                    ? wxFONTWEIGHT_LIGHT
                    : flags & wxFONTFLAG_BOLD
                        ? wxFONTWEIGHT_BOLD
                        : wxFONTWEIGHT_NORMAL;
}

static inline bool flags2Underlined(int flags)
{
    return (flags & wxFONTFLAG_UNDERLINED) != 0;
}

/* static */
wxFont *wxFontBase::New(int pointSize,
                        wxFontFamily family,
                        int flags,
                        const wxString& face,
                        wxFontEncoding encoding)
{
    return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
               flags2Underlined(flags), face, encoding);
}

/* static */
wxFont *wxFontBase::New(const wxSize& pixelSize,
                        int family,
                        int style,
                        int weight,
                        bool underlined,
                        const wxString& face,
                        wxFontEncoding encoding)
{
#if defined(__WXMSW__)
    return new wxFont(pixelSize, family, style, weight, underlined,
                      face, encoding);
#else
    wxFont *self = New(10, family, style, weight, underlined, face, encoding);
    wxScreenDC dc;
    AdjustFontSize(*(wxFont *)self, dc, pixelSize);
    return self;
#endif
}

/* static */
wxFont *wxFontBase::New(const wxSize& pixelSize,
                        wxFontFamily family,
                        int flags,
                        const wxString& face,
                        wxFontEncoding encoding)
{
    return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
               flags2Underlined(flags), face, encoding);
}

wxSize wxFontBase::GetPixelSize() const
{
    wxScreenDC dc;
    dc.SetFont(*(wxFont *)this);
    return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
}

bool wxFontBase::IsUsingSizeInPixels() const
{
    return false;
}

void wxFontBase::SetPixelSize( const wxSize& pixelSize )
{
    wxScreenDC dc;
    AdjustFontSize(*(wxFont *)this, dc, pixelSize);
}

/* 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;
}

void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
{
#ifdef wxNO_NATIVE_FONTINFO
    SetPointSize(info.pointSize);
    SetFamily(info.family);
    SetStyle(info.style);
    SetWeight(info.weight);
    SetUnderlined(info.underlined);
    SetFaceName(info.faceName);
    SetEncoding(info.encoding);
#else
    (void)info;
#endif
}

wxString wxFontBase::GetNativeFontInfoDesc() const
{
    wxString fontDesc;
    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;
    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) ||
           (
            Ok() == font.Ok() &&
            GetPointSize() == font.GetPointSize() &&
            // in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
            // operator==() resulting in infinite recursion so we can't use it
            // in that port
#if !defined(__WXGTK__) || defined(__WXGTK20__)
            GetPixelSize() == font.GetPixelSize() &&
#endif
            GetFamily() == font.GetFamily() &&
            GetStyle() == font.GetStyle() &&
            GetWeight() == font.GetWeight() &&
            GetUnderlined() == font.GetUnderlined() &&
            GetFaceName().IsSameAs(font.GetFaceName(), false) &&
            GetEncoding() == font.GetEncoding()
           );
}

bool wxFontBase::operator!=(const wxFont& font) const
{
    return !(*this == font);
}

wxString wxFontBase::GetFamilyString() const
{
    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );

    switch ( GetFamily() )
    {
        case wxDECORATIVE:   return wxT("wxDECORATIVE");
        case wxROMAN:        return wxT("wxROMAN");
        case wxSCRIPT:       return wxT("wxSCRIPT");
        case wxSWISS:        return wxT("wxSWISS");
        case wxMODERN:       return wxT("wxMODERN");
        case wxTELETYPE:     return wxT("wxTELETYPE");
        default:             return wxT("wxDEFAULT");
    }
}

wxString wxFontBase::GetStyleString() const
{
    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );

    switch ( GetStyle() )
    {
        case wxNORMAL:   return wxT("wxNORMAL");
        case wxSLANT:    return wxT("wxSLANT");
        case wxITALIC:   return wxT("wxITALIC");
        default:         return wxT("wxDEFAULT");
    }
}

wxString wxFontBase::GetWeightString() const
{
    wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );

    switch ( GetWeight() )
    {
        case wxNORMAL:   return wxT("wxNORMAL");
        case wxBOLD:     return wxT("wxBOLD");
        case wxLIGHT:    return wxT("wxLIGHT");
        default:         return wxT("wxDEFAULT");
    }
}

bool wxFontBase::SetFaceName(const wxString& facename)
{
#if wxUSE_FONTENUM
    if (!wxFontEnumerator::IsValidFacename(facename))
    {
        UnRef();        // make Ok() return false
        return false;
    }
#else // !wxUSE_FONTENUM
    wxUnusedVar(facename);
#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM

    return true;
}


// ----------------------------------------------------------------------------
// 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
}


#ifdef wxNO_NATIVE_FONTINFO

// These are the generic forms of FromString()/ToString.
//
// convert to/from the string representation: format is
//      version;pointsize;family;style;weight;underlined;facename;encoding

bool wxNativeFontInfo::FromString(const wxString& s)
{
    long l;

    wxStringTokenizer tokenizer(s, _T(";"));

    wxString token = tokenizer.GetNextToken();
    //
    //  Ignore the version for now
    //

    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;

    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(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
             0,                                 // version
             pointSize,
             family,
             (int)style,
             (int)weight,
             underlined,
             faceName.GetData(),
             (int)encoding);

    return s;
}

void wxNativeFontInfo::Init()
{
    pointSize = 0;
    family = wxFONTFAMILY_DEFAULT;
    style = wxFONTSTYLE_NORMAL;
    weight = wxFONTWEIGHT_NORMAL;
    underlined = false;
    faceName.clear();
    encoding = wxFONTENCODING_DEFAULT;
}

int wxNativeFontInfo::GetPointSize() const
{
    return pointSize;
}

wxFontStyle wxNativeFontInfo::GetStyle() const
{
    return style;
}

wxFontWeight wxNativeFontInfo::GetWeight() const
{
    return weight;
}

bool wxNativeFontInfo::GetUnderlined() const
{
    return underlined;
}

wxString wxNativeFontInfo::GetFaceName() const
{
    return faceName;
}

wxFontFamily wxNativeFontInfo::GetFamily() const
{
    return family;
}

wxFontEncoding wxNativeFontInfo::GetEncoding() const
{
    return encoding;
}

void wxNativeFontInfo::SetPointSize(int pointsize)
{
    pointSize = pointsize;
}

void wxNativeFontInfo::SetStyle(wxFontStyle style_)
{
    style = style_;
}

void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
{
    weight = weight_;
}

void wxNativeFontInfo::SetUnderlined(bool underlined_)
{
    underlined = underlined_;
}

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 (__WXPM__)

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");
    }

    switch ( GetWeight() )
    {
        default:
            wxFAIL_MSG( _T("unknown font weight") );
            // fall through

        case wxFONTWEIGHT_NORMAL:
            break;

        case wxFONTWEIGHT_LIGHT:
            desc << _(" light");
            break;

        case wxFONTWEIGHT_BOLD:
            desc << _(" bold");
            break;
    }

    switch ( GetStyle() )
    {
        default:
            wxFAIL_MSG( _T("unknown font style") );
            // fall through

        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() )
    {
        desc << _T(' ') << face;
    }

    int size = GetPointSize();
    if ( size != wxNORMAL_FONT->GetPointSize() )
    {
        desc << _T(' ') << size;
    }

#if wxUSE_FONTMAP
    wxFontEncoding enc = GetEncoding();
    if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
    {
        desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
    }
#endif // wxUSE_FONTMAP

    return desc.Strip(wxString::both).MakeLower();
}

bool wxNativeFontInfo::FromUserString(const wxString& s)
{
    // reset to the default state
    Init();

    // parse a more or less free form string
    //
    // TODO: we should handle at least the quoted facenames
    wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);

    wxString face;
    unsigned long size;
    bool weightfound = false, pointsizefound = false;
#if wxUSE_FONTMAP
    bool encodingfound = false;
#endif

    while ( tokenizer.HasMoreTokens() )
    {
        wxString token = tokenizer.GetNextToken();

        // normalize it
        token.Trim(true).Trim(false).MakeLower();

        // look for the known tokens
        if ( token == _T("underlined") || token == _("underlined") )
        {
            SetUnderlined(true);
        }
        else if ( token == _T("light") || token == _("light") )
        {
            SetWeight(wxFONTWEIGHT_LIGHT);
            weightfound = true;
        }
        else if ( token == _T("bold") || token == _("bold") )
        {
            SetWeight(wxFONTWEIGHT_BOLD);
            weightfound = true;
        }
        else if ( token == _T("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 += _T(' ');
            }

            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() )
        {
            // NB: the check on the facename is implemented in wxFontBase::SetFaceName
            //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
            //     call here wxFontEnumerator::IsValidFacename
            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 explicitely
        //     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 )
        SetPointSize(wxNORMAL_FONT->GetPointSize());

    // 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 or wxOS2


// 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, _T("NULL output parameter") );

    if ( str.empty() )
    {
        *font = wxNullFont;
        return true;
    }

    return font->SetNativeFontInfo(str);
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/fontcmn.cpp
	3	// Purpose: implementation of wxFontBase methods
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 20.09.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) wxWidgets team
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#include "wx/font.h"
	28
	29	#ifndef WX_PRECOMP
	30	#include "wx/dc.h"
	31	#include "wx/intl.h"
	32	#include "wx/dcscreen.h"
	33	#include "wx/log.h"
	34	#include "wx/gdicmn.h"
	35	#endif // WX_PRECOMP
	36
	37	#if defined(__WXMSW__)
	38	#include "wx/msw/private.h" // includes windows.h for LOGFONT
	39	#include "wx/msw/winundef.h"
	40	#endif
	41
	42	#include "wx/fontutil.h" // for wxNativeFontInfo
	43	#include "wx/fontmap.h"
	44	#include "wx/fontenum.h"
	45
	46	#include "wx/tokenzr.h"
	47
	48	// ============================================================================
	49	// implementation
	50	// ============================================================================
	51
	52	// ----------------------------------------------------------------------------
	53	// helper functions
	54	// ----------------------------------------------------------------------------
	55
	56	static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
	57	{
	58	int currentSize = 0;
	59	int largestGood = 0;
	60	int smallestBad = 0;
	61
	62	bool initialGoodFound = false;
	63	bool initialBadFound = false;
	64
	65	// NB: this assignment was separated from the variable definition
	66	// in order to fix a gcc v3.3.3 compiler crash
	67	currentSize = font.GetPointSize();
	68	while (currentSize > 0)
	69	{
	70	dc.SetFont(font);
	71
	72	// if currentSize (in points) results in a font that is smaller
	73	// than required by pixelSize it is considered a good size
	74	if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
	75	(!pixelSize.GetWidth() \|\|
	76	dc.GetCharWidth() <= pixelSize.GetWidth()))
	77	{
	78	largestGood = currentSize;
	79	initialGoodFound = true;
	80	}
	81	else
	82	{
	83	smallestBad = currentSize;
	84	initialBadFound = true;
	85	}
	86	if (!initialGoodFound)
	87	{
	88	currentSize /= 2;
	89	}
	90	else if (!initialBadFound)
	91	{
	92	currentSize *= 2;
	93	}
	94	else
	95	{
	96	int distance = smallestBad - largestGood;
	97	if (distance == 1)
	98	break;
	99
	100	currentSize = largestGood + distance / 2;
	101	}
	102
	103	font.SetPointSize(currentSize);
	104	}
	105
	106	if (currentSize != largestGood)
	107	font.SetPointSize(largestGood);
	108	}
	109
	110	// ----------------------------------------------------------------------------
	111	// wxFontBase
	112	// ----------------------------------------------------------------------------
	113
	114	wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
	115
	116	/* static */
	117	void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding)
	118	{
	119	// GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
	120	// and, besides, using this value here doesn't make any sense
	121	wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,
	122	_T("can't set default encoding to wxFONTENCODING_DEFAULT") );
	123
	124	ms_encodingDefault = encoding;
	125	}
	126
	127	wxFontBase::~wxFontBase()
	128	{
	129	// this destructor is required for Darwin
	130	}
	131
	132	/* static */
	133	wxFont *wxFontBase::New(int size,
	134	int family,
	135	int style,
	136	int weight,
	137	bool underlined,
	138	const wxString& face,
	139	wxFontEncoding encoding)
	140	{
	141	return new wxFont(size, family, style, weight, underlined, face, encoding);
	142	}
	143
	144	static inline int flags2Style(int flags)
	145	{
	146	return flags & wxFONTFLAG_ITALIC
	147	? wxFONTSTYLE_ITALIC
	148	: flags & wxFONTFLAG_SLANT
	149	? wxFONTSTYLE_SLANT
	150	: wxFONTSTYLE_NORMAL;
	151	}
	152
	153	static inline int flags2Weight(int flags)
	154	{
	155	return flags & wxFONTFLAG_LIGHT
	156	? wxFONTWEIGHT_LIGHT
	157	: flags & wxFONTFLAG_BOLD
	158	? wxFONTWEIGHT_BOLD
	159	: wxFONTWEIGHT_NORMAL;
	160	}
	161
	162	static inline bool flags2Underlined(int flags)
	163	{
	164	return (flags & wxFONTFLAG_UNDERLINED) != 0;
	165	}
	166
	167	/* static */
	168	wxFont *wxFontBase::New(int pointSize,
	169	wxFontFamily family,
	170	int flags,
	171	const wxString& face,
	172	wxFontEncoding encoding)
	173	{
	174	return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
	175	flags2Underlined(flags), face, encoding);
	176	}
	177
	178	/* static */
	179	wxFont *wxFontBase::New(const wxSize& pixelSize,
	180	int family,
	181	int style,
	182	int weight,
	183	bool underlined,
	184	const wxString& face,
	185	wxFontEncoding encoding)
	186	{
	187	#if defined(__WXMSW__)
	188	return new wxFont(pixelSize, family, style, weight, underlined,
	189	face, encoding);
	190	#else
	191	wxFont *self = New(10, family, style, weight, underlined, face, encoding);
	192	wxScreenDC dc;
	193	AdjustFontSize((wxFont )self, dc, pixelSize);
	194	return self;
	195	#endif
	196	}
	197
	198	/* static */
	199	wxFont *wxFontBase::New(const wxSize& pixelSize,
	200	wxFontFamily family,
	201	int flags,
	202	const wxString& face,
	203	wxFontEncoding encoding)
	204	{
	205	return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
	206	flags2Underlined(flags), face, encoding);
	207	}
	208
	209	wxSize wxFontBase::GetPixelSize() const
	210	{
	211	wxScreenDC dc;
	212	dc.SetFont((wxFont )this);
	213	return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
	214	}
	215
	216	bool wxFontBase::IsUsingSizeInPixels() const
	217	{
	218	return false;
	219	}
	220
	221	void wxFontBase::SetPixelSize( const wxSize& pixelSize )
	222	{
	223	wxScreenDC dc;
	224	AdjustFontSize((wxFont )this, dc, pixelSize);
	225	}
	226
	227	/* static */
	228	wxFont *wxFontBase::New(const wxNativeFontInfo& info)
	229	{
	230	return new wxFont(info);
	231	}
	232
	233	/* static */
	234	wxFont *wxFontBase::New(const wxString& strNativeFontDesc)
	235	{
	236	wxNativeFontInfo fontInfo;
	237	if ( !fontInfo.FromString(strNativeFontDesc) )
	238	return new wxFont(*wxNORMAL_FONT);
	239
	240	return New(fontInfo);
	241	}
	242
	243	bool wxFontBase::IsFixedWidth() const
	244	{
	245	return GetFamily() == wxFONTFAMILY_TELETYPE;
	246	}
	247
	248	void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
	249	{
	250	#ifdef wxNO_NATIVE_FONTINFO
	251	SetPointSize(info.pointSize);
	252	SetFamily(info.family);
	253	SetStyle(info.style);
	254	SetWeight(info.weight);
	255	SetUnderlined(info.underlined);
	256	SetFaceName(info.faceName);
	257	SetEncoding(info.encoding);
	258	#else
	259	(void)info;
	260	#endif
	261	}
	262
	263	wxString wxFontBase::GetNativeFontInfoDesc() const
	264	{
	265	wxString fontDesc;
	266	const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
	267	if ( fontInfo )
	268	{
	269	fontDesc = fontInfo->ToString();
	270	wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
	271	}
	272	else
	273	{
	274	wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
	275	}
	276
	277	return fontDesc;
	278	}
	279
	280	wxString wxFontBase::GetNativeFontInfoUserDesc() const
	281	{
	282	wxString fontDesc;
	283	const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
	284	if ( fontInfo )
	285	{
	286	fontDesc = fontInfo->ToUserString();
	287	wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
	288	}
	289	else
	290	{
	291	wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
	292	}
	293
	294	return fontDesc;
	295	}
	296
	297	bool wxFontBase::SetNativeFontInfo(const wxString& info)
	298	{
	299	wxNativeFontInfo fontInfo;
	300	if ( !info.empty() && fontInfo.FromString(info) )
	301	{
	302	SetNativeFontInfo(fontInfo);
	303	return true;
	304	}
	305
	306	return false;
	307	}
	308
	309	bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
	310	{
	311	wxNativeFontInfo fontInfo;
	312	if ( !info.empty() && fontInfo.FromUserString(info) )
	313	{
	314	SetNativeFontInfo(fontInfo);
	315	return true;
	316	}
	317
	318	return false;
	319	}
	320
	321	bool wxFontBase::operator==(const wxFont& font) const
	322	{
	323	// either it is the same font, i.e. they share the same common data or they
	324	// have different ref datas but still describe the same font
	325	return IsSameAs(font) \|\|
	326	(
	327	Ok() == font.Ok() &&
	328	GetPointSize() == font.GetPointSize() &&
	329	// in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
	330	// operator==() resulting in infinite recursion so we can't use it
	331	// in that port
	332	#if !defined(__WXGTK__) \|\| defined(__WXGTK20__)
	333	GetPixelSize() == font.GetPixelSize() &&
	334	#endif
	335	GetFamily() == font.GetFamily() &&
	336	GetStyle() == font.GetStyle() &&
	337	GetWeight() == font.GetWeight() &&
	338	GetUnderlined() == font.GetUnderlined() &&
	339	GetFaceName().IsSameAs(font.GetFaceName(), false) &&
	340	GetEncoding() == font.GetEncoding()
	341	);
	342	}
	343
	344	bool wxFontBase::operator!=(const wxFont& font) const
	345	{
	346	return !(*this == font);
	347	}
	348
	349	wxString wxFontBase::GetFamilyString() const
	350	{
	351	wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
	352
	353	switch ( GetFamily() )
	354	{
	355	case wxDECORATIVE: return wxT("wxDECORATIVE");
	356	case wxROMAN: return wxT("wxROMAN");
	357	case wxSCRIPT: return wxT("wxSCRIPT");
	358	case wxSWISS: return wxT("wxSWISS");
	359	case wxMODERN: return wxT("wxMODERN");
	360	case wxTELETYPE: return wxT("wxTELETYPE");
	361	default: return wxT("wxDEFAULT");
	362	}
	363	}
	364
	365	wxString wxFontBase::GetStyleString() const
	366	{
	367	wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
	368
	369	switch ( GetStyle() )
	370	{
	371	case wxNORMAL: return wxT("wxNORMAL");
	372	case wxSLANT: return wxT("wxSLANT");
	373	case wxITALIC: return wxT("wxITALIC");
	374	default: return wxT("wxDEFAULT");
	375	}
	376	}
	377
	378	wxString wxFontBase::GetWeightString() const
	379	{
	380	wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
	381
	382	switch ( GetWeight() )
	383	{
	384	case wxNORMAL: return wxT("wxNORMAL");
	385	case wxBOLD: return wxT("wxBOLD");
	386	case wxLIGHT: return wxT("wxLIGHT");
	387	default: return wxT("wxDEFAULT");
	388	}
	389	}
	390
	391	bool wxFontBase::SetFaceName(const wxString& facename)
	392	{
	393	#if wxUSE_FONTENUM
	394	if (!wxFontEnumerator::IsValidFacename(facename))
	395	{
	396	UnRef(); // make Ok() return false
	397	return false;
	398	}
	399	#else // !wxUSE_FONTENUM
	400	wxUnusedVar(facename);
	401	#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
	402
	403	return true;
	404	}
	405
	406
	407	// ----------------------------------------------------------------------------
	408	// wxNativeFontInfo
	409	// ----------------------------------------------------------------------------
	410
	411	// Up to now, there are no native implementations of this function:
	412	void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
	413	{
	414	#if wxUSE_FONTENUM
	415	for (size_t i=0; i < facenames.GetCount(); i++)
	416	{
	417	if (wxFontEnumerator::IsValidFacename(facenames[i]))
	418	{
	419	SetFaceName(facenames[i]);
	420	return;
	421	}
	422	}
	423
	424	// set the first valid facename we can find on this system
	425	wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
	426	wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
	427	SetFaceName(validfacename);
	428	#else // !wxUSE_FONTENUM
	429	SetFaceName(facenames[0]);
	430	#endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
	431	}
	432
	433
	434	#ifdef wxNO_NATIVE_FONTINFO
	435
	436	// These are the generic forms of FromString()/ToString.
	437	//
	438	// convert to/from the string representation: format is
	439	// version;pointsize;family;style;weight;underlined;facename;encoding
	440
	441	bool wxNativeFontInfo::FromString(const wxString& s)
	442	{
	443	long l;
	444
	445	wxStringTokenizer tokenizer(s, _T(";"));
	446
	447	wxString token = tokenizer.GetNextToken();
	448	//
	449	// Ignore the version for now
	450	//
	451
	452	token = tokenizer.GetNextToken();
	453	if ( !token.ToLong(&l) )
	454	return false;
	455	pointSize = (int)l;
	456
	457	token = tokenizer.GetNextToken();
	458	if ( !token.ToLong(&l) )
	459	return false;
	460	family = (wxFontFamily)l;
	461
	462	token = tokenizer.GetNextToken();
	463	if ( !token.ToLong(&l) )
	464	return false;
	465	style = (wxFontStyle)l;
	466
	467	token = tokenizer.GetNextToken();
	468	if ( !token.ToLong(&l) )
	469	return false;
	470	weight = (wxFontWeight)l;
	471
	472	token = tokenizer.GetNextToken();
	473	if ( !token.ToLong(&l) )
	474	return false;
	475	underlined = l != 0;
	476
	477	faceName = tokenizer.GetNextToken();
	478
	479	#ifndef __WXMAC__
	480	if( !faceName )
	481	return false;
	482	#endif
	483
	484	token = tokenizer.GetNextToken();
	485	if ( !token.ToLong(&l) )
	486	return false;
	487	encoding = (wxFontEncoding)l;
	488
	489	return true;
	490	}
	491
	492	wxString wxNativeFontInfo::ToString() const
	493	{
	494	wxString s;
	495
	496	s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
	497	0, // version
	498	pointSize,
	499	family,
	500	(int)style,
	501	(int)weight,
	502	underlined,
	503	faceName.GetData(),
	504	(int)encoding);
	505
	506	return s;
	507	}
	508
	509	void wxNativeFontInfo::Init()
	510	{
	511	pointSize = 0;
	512	family = wxFONTFAMILY_DEFAULT;
	513	style = wxFONTSTYLE_NORMAL;
	514	weight = wxFONTWEIGHT_NORMAL;
	515	underlined = false;
	516	faceName.clear();
	517	encoding = wxFONTENCODING_DEFAULT;
	518	}
	519
	520	int wxNativeFontInfo::GetPointSize() const
	521	{
	522	return pointSize;
	523	}
	524
	525	wxFontStyle wxNativeFontInfo::GetStyle() const
	526	{
	527	return style;
	528	}
	529
	530	wxFontWeight wxNativeFontInfo::GetWeight() const
	531	{
	532	return weight;
	533	}
	534
	535	bool wxNativeFontInfo::GetUnderlined() const
	536	{
	537	return underlined;
	538	}
	539
	540	wxString wxNativeFontInfo::GetFaceName() const
	541	{
	542	return faceName;
	543	}
	544
	545	wxFontFamily wxNativeFontInfo::GetFamily() const
	546	{
	547	return family;
	548	}
	549
	550	wxFontEncoding wxNativeFontInfo::GetEncoding() const
	551	{
	552	return encoding;
	553	}
	554
	555	void wxNativeFontInfo::SetPointSize(int pointsize)
	556	{
	557	pointSize = pointsize;
	558	}
	559
	560	void wxNativeFontInfo::SetStyle(wxFontStyle style_)
	561	{
	562	style = style_;
	563	}
	564
	565	void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
	566	{
	567	weight = weight_;
	568	}
	569
	570	void wxNativeFontInfo::SetUnderlined(bool underlined_)
	571	{
	572	underlined = underlined_;
	573	}
	574
	575	bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
	576	{
	577	faceName = facename_;
	578	return true;
	579	}
	580
	581	void wxNativeFontInfo::SetFamily(wxFontFamily family_)
	582	{
	583	family = family_;
	584	}
	585
	586	void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
	587	{
	588	encoding = encoding_;
	589	}
	590
	591	#endif // generic wxNativeFontInfo implementation
	592
	593	// conversion to/from user-readable string: this is used in the generic
	594	// versions and under MSW as well because there is no standard font description
	595	// format there anyhow (but there is a well-defined standard for X11 fonts used
	596	// by wxGTK and wxMotif)
	597
	598	#if defined(wxNO_NATIVE_FONTINFO) \|\| defined(__WXMSW__) \|\| defined (__WXPM__)
	599
	600	wxString wxNativeFontInfo::ToUserString() const
	601	{
	602	wxString desc;
	603
	604	// first put the adjectives, if any - this is English-centric, of course,
	605	// but what else can we do?
	606	if ( GetUnderlined() )
	607	{
	608	desc << _("underlined");
	609	}
	610
	611	switch ( GetWeight() )
	612	{
	613	default:
	614	wxFAIL_MSG( _T("unknown font weight") );
	615	// fall through
	616
	617	case wxFONTWEIGHT_NORMAL:
	618	break;
	619
	620	case wxFONTWEIGHT_LIGHT:
	621	desc << _(" light");
	622	break;
	623
	624	case wxFONTWEIGHT_BOLD:
	625	desc << _(" bold");
	626	break;
	627	}
	628
	629	switch ( GetStyle() )
	630	{
	631	default:
	632	wxFAIL_MSG( _T("unknown font style") );
	633	// fall through
	634
	635	case wxFONTSTYLE_NORMAL:
	636	break;
	637
	638	// we don't distinguish between the two for now anyhow...
	639	case wxFONTSTYLE_ITALIC:
	640	case wxFONTSTYLE_SLANT:
	641	desc << _(" italic");
	642	break;
	643	}
	644
	645	wxString face = GetFaceName();
	646	if ( !face.empty() )
	647	{
	648	desc << _T(' ') << face;
	649	}
	650
	651	int size = GetPointSize();
	652	if ( size != wxNORMAL_FONT->GetPointSize() )
	653	{
	654	desc << _T(' ') << size;
	655	}
	656
	657	#if wxUSE_FONTMAP
	658	wxFontEncoding enc = GetEncoding();
	659	if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
	660	{
	661	desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
	662	}
	663	#endif // wxUSE_FONTMAP
	664
	665	return desc.Strip(wxString::both).MakeLower();
	666	}
	667
	668	bool wxNativeFontInfo::FromUserString(const wxString& s)
	669	{
	670	// reset to the default state
	671	Init();
	672
	673	// parse a more or less free form string
	674	//
	675	// TODO: we should handle at least the quoted facenames
	676	wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);
	677
	678	wxString face;
	679	unsigned long size;
	680	bool weightfound = false, pointsizefound = false;
	681	#if wxUSE_FONTMAP
	682	bool encodingfound = false;
	683	#endif
	684
	685	while ( tokenizer.HasMoreTokens() )
	686	{
	687	wxString token = tokenizer.GetNextToken();
	688
	689	// normalize it
	690	token.Trim(true).Trim(false).MakeLower();
	691
	692	// look for the known tokens
	693	if ( token == _T("underlined") \|\| token == _("underlined") )
	694	{
	695	SetUnderlined(true);
	696	}
	697	else if ( token == _T("light") \|\| token == _("light") )
	698	{
	699	SetWeight(wxFONTWEIGHT_LIGHT);
	700	weightfound = true;
	701	}
	702	else if ( token == _T("bold") \|\| token == _("bold") )
	703	{
	704	SetWeight(wxFONTWEIGHT_BOLD);
	705	weightfound = true;
	706	}
	707	else if ( token == _T("italic") \|\| token == _("italic") )
	708	{
	709	SetStyle(wxFONTSTYLE_ITALIC);
	710	}
	711	else if ( token.ToULong(&size) )
	712	{
	713	SetPointSize(size);
	714	pointsizefound = true;
	715	}
	716	else
	717	{
	718	#if wxUSE_FONTMAP
	719	// try to interpret this as an encoding
	720	wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
	721	if ( encoding != wxFONTENCODING_DEFAULT &&
	722	encoding != wxFONTENCODING_SYSTEM ) // returned when the recognition failed
	723	{
	724	SetEncoding(encoding);
	725	encodingfound = true;
	726	}
	727	else
	728	{
	729	#endif // wxUSE_FONTMAP
	730
	731	// assume it is the face name
	732	if ( !face.empty() )
	733	{
	734	face += _T(' ');
	735	}
	736
	737	face += token;
	738
	739	// skip the code which resets face below
	740	continue;
	741
	742	#if wxUSE_FONTMAP
	743	}
	744	#endif // wxUSE_FONTMAP
	745	}
	746
	747	// if we had had the facename, we shouldn't continue appending tokens
	748	// to it (i.e. "foo bold bar" shouldn't result in the facename "foo
	749	// bar")
	750	if ( !face.empty() )
	751	{
	752	// NB: the check on the facename is implemented in wxFontBase::SetFaceName
	753	// and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
	754	// call here wxFontEnumerator::IsValidFacename
	755	if (
	756	#if wxUSE_FONTENUM
	757	!wxFontEnumerator::IsValidFacename(face) \|\|
	758	#endif // wxUSE_FONTENUM
	759	!SetFaceName(face) )
	760	{
	761	SetFaceName(wxNORMAL_FONT->GetFaceName());
	762	}
	763
	764	face.clear();
	765	}
	766	}
	767
	768	// we might not have flushed it inside the loop
	769	if ( !face.empty() )
	770	{
	771	// NB: the check on the facename is implemented in wxFontBase::SetFaceName
	772	// and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
	773	// call here wxFontEnumerator::IsValidFacename
	774	if (
	775	#if wxUSE_FONTENUM
	776	!wxFontEnumerator::IsValidFacename(face) \|\|
	777	#endif // wxUSE_FONTENUM
	778	!SetFaceName(face) )
	779	{
	780	SetFaceName(wxNORMAL_FONT->GetFaceName());
	781	}
	782	}
	783
	784	// set point size to default value if size was not given
	785	if ( !pointsizefound )
	786	SetPointSize(wxNORMAL_FONT->GetPointSize());
	787
	788	// set font weight to default value if weight was not given
	789	if ( !weightfound )
	790	SetWeight(wxFONTWEIGHT_NORMAL);
	791
	792	#if wxUSE_FONTMAP
	793	// set font encoding to default value if encoding was not given
	794	if ( !encodingfound )
	795	SetEncoding(wxFONTENCODING_SYSTEM);
	796	#endif // wxUSE_FONTMAP
	797
	798	return true;
	799	}
	800
	801	#endif // generic or wxMSW or wxOS2
	802
	803
	804	// wxFont <-> wxString utilities, used by wxConfig
	805	wxString wxToString(const wxFontBase& font)
	806	{
	807	return font.IsOk() ? font.GetNativeFontInfoDesc()
	808	: wxString();
	809	}
	810
	811	bool wxFromString(const wxString& str, wxFontBase *font)
	812	{
	813	wxCHECK_MSG( font, false, _T("NULL output parameter") );
	814
	815	if ( str.empty() )
	816	{
	817	*font = wxNullFont;
	818	return true;
	819	}
	820
	821	return font->SetNativeFontInfo(str);
	822	}
	823
	824