src/gtk/font.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/font.cpp
// Purpose:     wxFont for wxGTK
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling and Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/font.h"

#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/utils.h"
    #include "wx/settings.h"
    #include "wx/gdicmn.h"
#endif

#include "wx/fontutil.h"
#include "wx/tokenzr.h"

#include "wx/gtk/private.h"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// the default size (in points) for the fonts
static const int wxDEFAULT_FONT_SIZE = 12;

// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------

class wxFontRefData : public wxGDIRefData
{
public:
    // from broken down font parameters, also default ctor
    wxFontRefData(int size = -1,
                  wxFontFamily family = wxFONTFAMILY_DEFAULT,
                  wxFontStyle style = wxFONTSTYLE_NORMAL,
                  wxFontWeight weight = wxFONTWEIGHT_NORMAL,
                  bool underlined = false,
                  bool strikethrough = false,
                  const wxString& faceName = wxEmptyString,
                  wxFontEncoding encoding = wxFONTENCODING_DEFAULT);

    wxFontRefData(const wxString& nativeFontInfoString);

    // copy ctor
    wxFontRefData( const wxFontRefData& data );

    virtual ~wxFontRefData();

    // setters: all of them also take care to modify m_nativeFontInfo if we
    // have it so as to not lose the information not carried by our fields
    void SetPointSize(int pointSize);
    void SetFamily(wxFontFamily family);
    void SetStyle(wxFontStyle style);
    void SetWeight(wxFontWeight weight);
    void SetUnderlined(bool underlined);
    void SetStrikethrough(bool strikethrough);
    bool SetFaceName(const wxString& facename);
    void SetEncoding(wxFontEncoding encoding);

    // and this one also modifies all the other font data fields
    void SetNativeFontInfo(const wxNativeFontInfo& info);

protected:
    // common part of all ctors
    void Init(int pointSize,
              wxFontFamily family,
              wxFontStyle style,
              wxFontWeight weight,
              bool underlined,
              bool strikethrough,
              const wxString& faceName,
              wxFontEncoding encoding);

    // set all fields from (already initialized and valid) m_nativeFontInfo
    void InitFromNative();

private:
    bool            m_underlined;
    bool            m_strikethrough;
    // The native font info: basically a PangoFontDescription
    wxNativeFontInfo m_nativeFontInfo;

    friend class wxFont;
};

#define M_FONTDATA ((wxFontRefData*)m_refData)

// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------

void wxFontRefData::Init(int pointSize,
                         wxFontFamily family,
                         wxFontStyle style,
                         wxFontWeight weight,
                         bool underlined,
                         bool strikethrough,
                         const wxString& faceName,
                         wxFontEncoding WXUNUSED(encoding))
{
    if (family == wxFONTFAMILY_DEFAULT)
        family = wxFONTFAMILY_SWISS;

    m_underlined = underlined;
    m_strikethrough = strikethrough;

    // Create native font info
    m_nativeFontInfo.description = pango_font_description_new();

    // And set its values
    if (!faceName.empty())
    {
        pango_font_description_set_family( m_nativeFontInfo.description,
                                           wxGTK_CONV_SYS(faceName) );
    }
    else
    {
        SetFamily(family);
    }

    SetStyle( style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style );
    SetPointSize( (pointSize == wxDEFAULT || pointSize == -1)
                    ? wxDEFAULT_FONT_SIZE
                    : pointSize );
    SetWeight( weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight );
}

void wxFontRefData::InitFromNative()
{
    // Get native info
    PangoFontDescription *desc = m_nativeFontInfo.description;

    // Pango sometimes needs to have a size
    int pango_size = pango_font_description_get_size( desc );
    if (pango_size == 0)
        m_nativeFontInfo.SetPointSize(wxDEFAULT_FONT_SIZE);

    // Pango description are never underlined
    m_underlined = false;
    m_strikethrough = false;
}

wxFontRefData::wxFontRefData( const wxFontRefData& data )
             : wxGDIRefData()
{
    m_underlined = data.m_underlined;
    m_strikethrough = data.m_strikethrough;

    // Forces a copy of the internal data.  wxNativeFontInfo should probably
    // have a copy ctor and assignment operator to fix this properly but that
    // would break binary compatibility...
    m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
}

wxFontRefData::wxFontRefData(int size, wxFontFamily family, wxFontStyle style,
                             wxFontWeight weight, bool underlined, bool strikethrough,
                             const wxString& faceName,
                             wxFontEncoding encoding)
{
    Init(size, family, style, weight, underlined, strikethrough, faceName, encoding);
}

wxFontRefData::wxFontRefData(const wxString& nativeFontInfoString)
{
    m_nativeFontInfo.FromString( nativeFontInfoString );

    InitFromNative();
}

wxFontRefData::~wxFontRefData()
{
}

// ----------------------------------------------------------------------------
// wxFontRefData SetXXX()
// ----------------------------------------------------------------------------

void wxFontRefData::SetPointSize(int pointSize)
{
    m_nativeFontInfo.SetPointSize(pointSize);
}

/*
    NOTE: disabled because pango_font_description_set_absolute_size() and
          wxDC::GetCharHeight() do not mix well: setting with the former a pixel
          size of "30" makes the latter return 36...
          Besides, we need to return GetPointSize() a point size value even if
          SetPixelSize() was used and this would require further changes
          (and use of pango_font_description_get_size_is_absolute in some places).

bool wxFontRefData::SetPixelSize(const wxSize& pixelSize)
{
    wxCHECK_MSG( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0, false,
                 "Negative values for the pixel size or zero pixel height are not allowed" );

    if (wx_pango_version_check(1,8,0) != NULL ||
        pixelSize.GetWidth() != 0)
    {
        // NOTE: pango_font_description_set_absolute_size() only sets the font height;
        //       if the user set the pixel width of the font explicitly or the pango
        //       library is too old, we cannot proceed
        return false;
    }

    pango_font_description_set_absolute_size( m_nativeFontInfo.description,
                                              pixelSize.GetHeight() * PANGO_SCALE );

    return true;
}
*/

void wxFontRefData::SetFamily(wxFontFamily family)
{
    m_nativeFontInfo.SetFamily(family);
}

void wxFontRefData::SetStyle(wxFontStyle style)
{
    m_nativeFontInfo.SetStyle(style);
}

void wxFontRefData::SetWeight(wxFontWeight weight)
{
    m_nativeFontInfo.SetWeight(weight);
}

void wxFontRefData::SetUnderlined(bool underlined)
{
    m_underlined = underlined;

    // the Pango font descriptor does not have an underlined attribute
    // (and wxNativeFontInfo::SetUnderlined asserts); rather it's
    // wxWindowDCImpl::DoDrawText that handles underlined fonts, so we
    // here we just need to save the underlined attribute
}

void wxFontRefData::SetStrikethrough(bool strikethrough)
{
    m_strikethrough = strikethrough;
}

bool wxFontRefData::SetFaceName(const wxString& facename)
{
    return m_nativeFontInfo.SetFaceName(facename);
}

void wxFontRefData::SetEncoding(wxFontEncoding WXUNUSED(encoding))
{
    // with GTK+ 2 Pango always uses UTF8 internally, we cannot change it
}

void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
{
    m_nativeFontInfo = info;

    // set all the other font parameters from the native font info
    InitFromNative();
}

// ----------------------------------------------------------------------------
// wxFont creation
// ----------------------------------------------------------------------------

wxFont::wxFont(const wxNativeFontInfo& info)
{
    Create( info.GetPointSize(),
            info.GetFamily(),
            info.GetStyle(),
            info.GetWeight(),
            info.GetUnderlined(),
            info.GetFaceName(),
            info.GetEncoding() );
}

wxFont::wxFont(int pointSize,
               wxFontFamily family,
               int flags,
               const wxString& face,
               wxFontEncoding encoding)
{
    m_refData = new wxFontRefData(pointSize, family,
                                  GetStyleFromFlags(flags),
                                  GetWeightFromFlags(flags),
                                  GetUnderlinedFromFlags(flags),
                                  false, face, encoding);
}

bool wxFont::Create( int pointSize,
                     wxFontFamily family,
                     wxFontStyle style,
                     wxFontWeight weight,
                     bool underlined,
                     const wxString& face,
                     wxFontEncoding encoding )
{
    UnRef();

    m_refData = new wxFontRefData(pointSize, family, style, weight,
                                  underlined, false, face, encoding);

    return true;
}

bool wxFont::Create(const wxString& fontname)
{
    // VZ: does this really happen?
    if ( fontname.empty() )
    {
        *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);

        return true;
    }

    m_refData = new wxFontRefData(fontname);

    return true;
}

wxFont::~wxFont()
{
}

// ----------------------------------------------------------------------------
// accessors
// ----------------------------------------------------------------------------

int wxFont::GetPointSize() const
{
    wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );

    return M_FONTDATA->m_nativeFontInfo.GetPointSize();
}

wxString wxFont::GetFaceName() const
{
    wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );

    return M_FONTDATA->m_nativeFontInfo.GetFaceName();
}

wxFontFamily wxFont::DoGetFamily() const
{
    return M_FONTDATA->m_nativeFontInfo.GetFamily();
}

wxFontStyle wxFont::GetStyle() const
{
    wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );

    return M_FONTDATA->m_nativeFontInfo.GetStyle();
}

wxFontWeight wxFont::GetWeight() const
{
    wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );

    return M_FONTDATA->m_nativeFontInfo.GetWeight();
}

bool wxFont::GetUnderlined() const
{
    wxCHECK_MSG( IsOk(), false, wxT("invalid font") );

    return M_FONTDATA->m_underlined;
}

bool wxFont::GetStrikethrough() const
{
    wxCHECK_MSG( IsOk(), false, wxT("invalid font") );

    return M_FONTDATA->m_strikethrough;
}

wxFontEncoding wxFont::GetEncoding() const
{
    wxCHECK_MSG( IsOk(), wxFONTENCODING_SYSTEM, wxT("invalid font") );

    return wxFONTENCODING_UTF8;
        // Pango always uses UTF8... see also SetEncoding()
}

const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
    wxCHECK_MSG( IsOk(), NULL, wxT("invalid font") );

    return &(M_FONTDATA->m_nativeFontInfo);
}

bool wxFont::IsFixedWidth() const
{
    wxCHECK_MSG( IsOk(), false, wxT("invalid font") );

    return wxFontBase::IsFixedWidth();
}

// ----------------------------------------------------------------------------
// change font attributes
// ----------------------------------------------------------------------------

void wxFont::SetPointSize(int pointSize)
{
    AllocExclusive();

    M_FONTDATA->SetPointSize(pointSize);
}

void wxFont::SetFamily(wxFontFamily family)
{
    AllocExclusive();

    M_FONTDATA->SetFamily(family);
}

void wxFont::SetStyle(wxFontStyle style)
{
    AllocExclusive();

    M_FONTDATA->SetStyle(style);
}

void wxFont::SetWeight(wxFontWeight weight)
{
    AllocExclusive();

    M_FONTDATA->SetWeight(weight);
}

bool wxFont::SetFaceName(const wxString& faceName)
{
    AllocExclusive();

    return M_FONTDATA->SetFaceName(faceName) &&
           wxFontBase::SetFaceName(faceName);
}

void wxFont::SetUnderlined(bool underlined)
{
    AllocExclusive();

    M_FONTDATA->SetUnderlined(underlined);
}

void wxFont::SetStrikethrough(bool strikethrough)
{
    AllocExclusive();

    M_FONTDATA->SetStrikethrough(strikethrough);
}

void wxFont::SetEncoding(wxFontEncoding encoding)
{
    AllocExclusive();

    M_FONTDATA->SetEncoding(encoding);
}

void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
{
    AllocExclusive();

    M_FONTDATA->SetNativeFontInfo( info );
}

wxGDIRefData* wxFont::CreateGDIRefData() const
{
    return new wxFontRefData;
}

wxGDIRefData* wxFont::CloneGDIRefData(const wxGDIRefData* data) const
{
    return new wxFontRefData(*static_cast<const wxFontRefData*>(data));
}

bool wxFont::GTKSetPangoAttrs(PangoLayout* layout) const
{
    if (!IsOk() || !(GetUnderlined() || GetStrikethrough()))
        return false;

    PangoAttrList* attrs = pango_attr_list_new();
    PangoAttribute* a;

    if (wx_pango_version_check(1,16,0))
    {
        // a PangoLayout which has leading/trailing spaces with underlined font
        // is not correctly drawn by this pango version: Pango won't underline the spaces.
        // This can be a problem; e.g. wxHTML rendering of underlined text relies on
        // this behaviour. To workaround this problem, we use a special hack here
        // suggested by pango maintainer Behdad Esfahbod: we prepend and append two
        // empty space characters and give them a dummy colour attribute.
        // This will force Pango to underline the leading/trailing spaces, too.

        const char* text = pango_layout_get_text(layout);
        const size_t n = strlen(text);
        if ((n > 0 && text[0] == ' ') || (n > 1 && text[n - 1] == ' '))
        {
            wxCharBuffer buf(n + 6);
            // copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
            memcpy(buf.data(), "\342\200\214", 3);
            // copy the user string
            memcpy(buf.data() + 3, text, n);
            // copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
            memcpy(buf.data() + 3 + n, "\342\200\214", 3);

            pango_layout_set_text(layout, buf, n + 6);

            // Add dummy attributes (use colour as it's invisible anyhow for 0
            // width spaces) to ensure that the spaces in the beginning/end of the
            // string are underlined too.
            a = pango_attr_foreground_new(0x0057, 0x52A9, 0xD614);
            a->start_index = 0;
            a->end_index = 3;
            pango_attr_list_insert(attrs, a);

            a = pango_attr_foreground_new(0x0057, 0x52A9, 0xD614);
            a->start_index = n + 3;
            a->end_index = n + 6;
            pango_attr_list_insert(attrs, a);
        }
    }
    if (GetUnderlined())
    {
        a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
        pango_attr_list_insert(attrs, a);
    }
    if (GetStrikethrough())
    {
        a = pango_attr_strikethrough_new(true);
        pango_attr_list_insert(attrs, a);
    }

    pango_layout_set_attributes(layout, attrs);
    pango_attr_list_unref(attrs);

    return true;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/font.cpp
	3	// Purpose: wxFont for wxGTK
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling and Julian Smart
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// ============================================================================
	11	// declarations
	12	// ============================================================================
	13
	14	// ----------------------------------------------------------------------------
	15	// headers
	16	// ----------------------------------------------------------------------------
	17
	18	// For compilers that support precompilation, includes "wx.h".
	19	#include "wx/wxprec.h"
	20
	21	#include "wx/font.h"
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/log.h"
	25	#include "wx/utils.h"
	26	#include "wx/settings.h"
	27	#include "wx/gdicmn.h"
	28	#endif
	29
	30	#include "wx/fontutil.h"
	31	#include "wx/tokenzr.h"
	32
	33	#include "wx/gtk/private.h"
	34
	35	// ----------------------------------------------------------------------------
	36	// constants
	37	// ----------------------------------------------------------------------------
	38
	39	// the default size (in points) for the fonts
	40	static const int wxDEFAULT_FONT_SIZE = 12;
	41
	42	// ----------------------------------------------------------------------------
	43	// wxFontRefData
	44	// ----------------------------------------------------------------------------
	45
	46	class wxFontRefData : public wxGDIRefData
	47	{
	48	public:
	49	// from broken down font parameters, also default ctor
	50	wxFontRefData(int size = -1,
	51	wxFontFamily family = wxFONTFAMILY_DEFAULT,
	52	wxFontStyle style = wxFONTSTYLE_NORMAL,
	53	wxFontWeight weight = wxFONTWEIGHT_NORMAL,
	54	bool underlined = false,
	55	bool strikethrough = false,
	56	const wxString& faceName = wxEmptyString,
	57	wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
	58
	59	wxFontRefData(const wxString& nativeFontInfoString);
	60
	61	// copy ctor
	62	wxFontRefData( const wxFontRefData& data );
	63
	64	virtual ~wxFontRefData();
	65
	66	// setters: all of them also take care to modify m_nativeFontInfo if we
	67	// have it so as to not lose the information not carried by our fields
	68	void SetPointSize(int pointSize);
	69	void SetFamily(wxFontFamily family);
	70	void SetStyle(wxFontStyle style);
	71	void SetWeight(wxFontWeight weight);
	72	void SetUnderlined(bool underlined);
	73	void SetStrikethrough(bool strikethrough);
	74	bool SetFaceName(const wxString& facename);
	75	void SetEncoding(wxFontEncoding encoding);
	76
	77	// and this one also modifies all the other font data fields
	78	void SetNativeFontInfo(const wxNativeFontInfo& info);
	79
	80	protected:
	81	// common part of all ctors
	82	void Init(int pointSize,
	83	wxFontFamily family,
	84	wxFontStyle style,
	85	wxFontWeight weight,
	86	bool underlined,
	87	bool strikethrough,
	88	const wxString& faceName,
	89	wxFontEncoding encoding);
	90
	91	// set all fields from (already initialized and valid) m_nativeFontInfo
	92	void InitFromNative();
	93
	94	private:
	95	bool m_underlined;
	96	bool m_strikethrough;
	97	// The native font info: basically a PangoFontDescription
	98	wxNativeFontInfo m_nativeFontInfo;
	99
	100	friend class wxFont;
	101	};
	102
	103	#define M_FONTDATA ((wxFontRefData*)m_refData)
	104
	105	// ----------------------------------------------------------------------------
	106	// wxFontRefData
	107	// ----------------------------------------------------------------------------
	108
	109	void wxFontRefData::Init(int pointSize,
	110	wxFontFamily family,
	111	wxFontStyle style,
	112	wxFontWeight weight,
	113	bool underlined,
	114	bool strikethrough,
	115	const wxString& faceName,
	116	wxFontEncoding WXUNUSED(encoding))
	117	{
	118	if (family == wxFONTFAMILY_DEFAULT)
	119	family = wxFONTFAMILY_SWISS;
	120
	121	m_underlined = underlined;
	122	m_strikethrough = strikethrough;
	123
	124	// Create native font info
	125	m_nativeFontInfo.description = pango_font_description_new();
	126
	127	// And set its values
	128	if (!faceName.empty())
	129	{
	130	pango_font_description_set_family( m_nativeFontInfo.description,
	131	wxGTK_CONV_SYS(faceName) );
	132	}
	133	else
	134	{
	135	SetFamily(family);
	136	}
	137
	138	SetStyle( style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style );
	139	SetPointSize( (pointSize == wxDEFAULT \|\| pointSize == -1)
	140	? wxDEFAULT_FONT_SIZE
	141	: pointSize );
	142	SetWeight( weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight );
	143	}
	144
	145	void wxFontRefData::InitFromNative()
	146	{
	147	// Get native info
	148	PangoFontDescription *desc = m_nativeFontInfo.description;
	149
	150	// Pango sometimes needs to have a size
	151	int pango_size = pango_font_description_get_size( desc );
	152	if (pango_size == 0)
	153	m_nativeFontInfo.SetPointSize(wxDEFAULT_FONT_SIZE);
	154
	155	// Pango description are never underlined
	156	m_underlined = false;
	157	m_strikethrough = false;
	158	}
	159
	160	wxFontRefData::wxFontRefData( const wxFontRefData& data )
	161	: wxGDIRefData()
	162	{
	163	m_underlined = data.m_underlined;
	164	m_strikethrough = data.m_strikethrough;
	165
	166	// Forces a copy of the internal data. wxNativeFontInfo should probably
	167	// have a copy ctor and assignment operator to fix this properly but that
	168	// would break binary compatibility...
	169	m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
	170	}
	171
	172	wxFontRefData::wxFontRefData(int size, wxFontFamily family, wxFontStyle style,
	173	wxFontWeight weight, bool underlined, bool strikethrough,
	174	const wxString& faceName,
	175	wxFontEncoding encoding)
	176	{
	177	Init(size, family, style, weight, underlined, strikethrough, faceName, encoding);
	178	}
	179
	180	wxFontRefData::wxFontRefData(const wxString& nativeFontInfoString)
	181	{
	182	m_nativeFontInfo.FromString( nativeFontInfoString );
	183
	184	InitFromNative();
	185	}
	186
	187	wxFontRefData::~wxFontRefData()
	188	{
	189	}
	190
	191	// ----------------------------------------------------------------------------
	192	// wxFontRefData SetXXX()
	193	// ----------------------------------------------------------------------------
	194
	195	void wxFontRefData::SetPointSize(int pointSize)
	196	{
	197	m_nativeFontInfo.SetPointSize(pointSize);
	198	}
	199
	200	/*
	201	NOTE: disabled because pango_font_description_set_absolute_size() and
	202	wxDC::GetCharHeight() do not mix well: setting with the former a pixel
	203	size of "30" makes the latter return 36...
	204	Besides, we need to return GetPointSize() a point size value even if
	205	SetPixelSize() was used and this would require further changes
	206	(and use of pango_font_description_get_size_is_absolute in some places).
	207
	208	bool wxFontRefData::SetPixelSize(const wxSize& pixelSize)
	209	{
	210	wxCHECK_MSG( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0, false,
	211	"Negative values for the pixel size or zero pixel height are not allowed" );
	212
	213	if (wx_pango_version_check(1,8,0) != NULL \|\|
	214	pixelSize.GetWidth() != 0)
	215	{
	216	// NOTE: pango_font_description_set_absolute_size() only sets the font height;
	217	// if the user set the pixel width of the font explicitly or the pango
	218	// library is too old, we cannot proceed
	219	return false;
	220	}
	221
	222	pango_font_description_set_absolute_size( m_nativeFontInfo.description,
	223	pixelSize.GetHeight() * PANGO_SCALE );
	224
	225	return true;
	226	}
	227	*/
	228
	229	void wxFontRefData::SetFamily(wxFontFamily family)
	230	{
	231	m_nativeFontInfo.SetFamily(family);
	232	}
	233
	234	void wxFontRefData::SetStyle(wxFontStyle style)
	235	{
	236	m_nativeFontInfo.SetStyle(style);
	237	}
	238
	239	void wxFontRefData::SetWeight(wxFontWeight weight)
	240	{
	241	m_nativeFontInfo.SetWeight(weight);
	242	}
	243
	244	void wxFontRefData::SetUnderlined(bool underlined)
	245	{
	246	m_underlined = underlined;
	247
	248	// the Pango font descriptor does not have an underlined attribute
	249	// (and wxNativeFontInfo::SetUnderlined asserts); rather it's
	250	// wxWindowDCImpl::DoDrawText that handles underlined fonts, so we
	251	// here we just need to save the underlined attribute
	252	}
	253
	254	void wxFontRefData::SetStrikethrough(bool strikethrough)
	255	{
	256	m_strikethrough = strikethrough;
	257	}
	258
	259	bool wxFontRefData::SetFaceName(const wxString& facename)
	260	{
	261	return m_nativeFontInfo.SetFaceName(facename);
	262	}
	263
	264	void wxFontRefData::SetEncoding(wxFontEncoding WXUNUSED(encoding))
	265	{
	266	// with GTK+ 2 Pango always uses UTF8 internally, we cannot change it
	267	}
	268
	269	void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
	270	{
	271	m_nativeFontInfo = info;
	272
	273	// set all the other font parameters from the native font info
	274	InitFromNative();
	275	}
	276
	277	// ----------------------------------------------------------------------------
	278	// wxFont creation
	279	// ----------------------------------------------------------------------------
	280
	281	wxFont::wxFont(const wxNativeFontInfo& info)
	282	{
	283	Create( info.GetPointSize(),
	284	info.GetFamily(),
	285	info.GetStyle(),
	286	info.GetWeight(),
	287	info.GetUnderlined(),
	288	info.GetFaceName(),
	289	info.GetEncoding() );
	290	}
	291
	292	wxFont::wxFont(int pointSize,
	293	wxFontFamily family,
	294	int flags,
	295	const wxString& face,
	296	wxFontEncoding encoding)
	297	{
	298	m_refData = new wxFontRefData(pointSize, family,
	299	GetStyleFromFlags(flags),
	300	GetWeightFromFlags(flags),
	301	GetUnderlinedFromFlags(flags),
	302	false, face, encoding);
	303	}
	304
	305	bool wxFont::Create( int pointSize,
	306	wxFontFamily family,
	307	wxFontStyle style,
	308	wxFontWeight weight,
	309	bool underlined,
	310	const wxString& face,
	311	wxFontEncoding encoding )
	312	{
	313	UnRef();
	314
	315	m_refData = new wxFontRefData(pointSize, family, style, weight,
	316	underlined, false, face, encoding);
	317
	318	return true;
	319	}
	320
	321	bool wxFont::Create(const wxString& fontname)
	322	{
	323	// VZ: does this really happen?
	324	if ( fontname.empty() )
	325	{
	326	*this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
	327
	328	return true;
	329	}
	330
	331	m_refData = new wxFontRefData(fontname);
	332
	333	return true;
	334	}
	335
	336	wxFont::~wxFont()
	337	{
	338	}
	339
	340	// ----------------------------------------------------------------------------
	341	// accessors
	342	// ----------------------------------------------------------------------------
	343
	344	int wxFont::GetPointSize() const
	345	{
	346	wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );
	347
	348	return M_FONTDATA->m_nativeFontInfo.GetPointSize();
	349	}
	350
	351	wxString wxFont::GetFaceName() const
	352	{
	353	wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
	354
	355	return M_FONTDATA->m_nativeFontInfo.GetFaceName();
	356	}
	357
	358	wxFontFamily wxFont::DoGetFamily() const
	359	{
	360	return M_FONTDATA->m_nativeFontInfo.GetFamily();
	361	}
	362
	363	wxFontStyle wxFont::GetStyle() const
	364	{
	365	wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );
	366
	367	return M_FONTDATA->m_nativeFontInfo.GetStyle();
	368	}
	369
	370	wxFontWeight wxFont::GetWeight() const
	371	{
	372	wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );
	373
	374	return M_FONTDATA->m_nativeFontInfo.GetWeight();
	375	}
	376
	377	bool wxFont::GetUnderlined() const
	378	{
	379	wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
	380
	381	return M_FONTDATA->m_underlined;
	382	}
	383
	384	bool wxFont::GetStrikethrough() const
	385	{
	386	wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
	387
	388	return M_FONTDATA->m_strikethrough;
	389	}
	390
	391	wxFontEncoding wxFont::GetEncoding() const
	392	{
	393	wxCHECK_MSG( IsOk(), wxFONTENCODING_SYSTEM, wxT("invalid font") );
	394
	395	return wxFONTENCODING_UTF8;
	396	// Pango always uses UTF8... see also SetEncoding()
	397	}
	398
	399	const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
	400	{
	401	wxCHECK_MSG( IsOk(), NULL, wxT("invalid font") );
	402
	403	return &(M_FONTDATA->m_nativeFontInfo);
	404	}
	405
	406	bool wxFont::IsFixedWidth() const
	407	{
	408	wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
	409
	410	return wxFontBase::IsFixedWidth();
	411	}
	412
	413	// ----------------------------------------------------------------------------
	414	// change font attributes
	415	// ----------------------------------------------------------------------------
	416
	417	void wxFont::SetPointSize(int pointSize)
	418	{
	419	AllocExclusive();
	420
	421	M_FONTDATA->SetPointSize(pointSize);
	422	}
	423
	424	void wxFont::SetFamily(wxFontFamily family)
	425	{
	426	AllocExclusive();
	427
	428	M_FONTDATA->SetFamily(family);
	429	}
	430
	431	void wxFont::SetStyle(wxFontStyle style)
	432	{
	433	AllocExclusive();
	434
	435	M_FONTDATA->SetStyle(style);
	436	}
	437
	438	void wxFont::SetWeight(wxFontWeight weight)
	439	{
	440	AllocExclusive();
	441
	442	M_FONTDATA->SetWeight(weight);
	443	}
	444
	445	bool wxFont::SetFaceName(const wxString& faceName)
	446	{
	447	AllocExclusive();
	448
	449	return M_FONTDATA->SetFaceName(faceName) &&
	450	wxFontBase::SetFaceName(faceName);
	451	}
	452
	453	void wxFont::SetUnderlined(bool underlined)
	454	{
	455	AllocExclusive();
	456
	457	M_FONTDATA->SetUnderlined(underlined);
	458	}
	459
	460	void wxFont::SetStrikethrough(bool strikethrough)
	461	{
	462	AllocExclusive();
	463
	464	M_FONTDATA->SetStrikethrough(strikethrough);
	465	}
	466
	467	void wxFont::SetEncoding(wxFontEncoding encoding)
	468	{
	469	AllocExclusive();
	470
	471	M_FONTDATA->SetEncoding(encoding);
	472	}
	473
	474	void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
	475	{
	476	AllocExclusive();
	477
	478	M_FONTDATA->SetNativeFontInfo( info );
	479	}
	480
	481	wxGDIRefData* wxFont::CreateGDIRefData() const
	482	{
	483	return new wxFontRefData;
	484	}
	485
	486	wxGDIRefData* wxFont::CloneGDIRefData(const wxGDIRefData* data) const
	487	{
	488	return new wxFontRefData(static_cast<const wxFontRefData>(data));
	489	}
	490
	491	bool wxFont::GTKSetPangoAttrs(PangoLayout* layout) const
	492	{
	493	if (!IsOk() \|\| !(GetUnderlined() \|\| GetStrikethrough()))
	494	return false;
	495
	496	PangoAttrList* attrs = pango_attr_list_new();
	497	PangoAttribute* a;
	498
	499	if (wx_pango_version_check(1,16,0))
	500	{
	501	// a PangoLayout which has leading/trailing spaces with underlined font
	502	// is not correctly drawn by this pango version: Pango won't underline the spaces.
	503	// This can be a problem; e.g. wxHTML rendering of underlined text relies on
	504	// this behaviour. To workaround this problem, we use a special hack here
	505	// suggested by pango maintainer Behdad Esfahbod: we prepend and append two
	506	// empty space characters and give them a dummy colour attribute.
	507	// This will force Pango to underline the leading/trailing spaces, too.
	508
	509	const char* text = pango_layout_get_text(layout);
	510	const size_t n = strlen(text);
	511	if ((n > 0 && text[0] == ' ') \|\| (n > 1 && text[n - 1] == ' '))
	512	{
	513	wxCharBuffer buf(n + 6);
	514	// copy the leading U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
	515	memcpy(buf.data(), "\342\200\214", 3);
	516	// copy the user string
	517	memcpy(buf.data() + 3, text, n);
	518	// copy the trailing U+200C ZERO WIDTH NON-JOINER encoded in UTF8 format
	519	memcpy(buf.data() + 3 + n, "\342\200\214", 3);
	520
	521	pango_layout_set_text(layout, buf, n + 6);
	522
	523	// Add dummy attributes (use colour as it's invisible anyhow for 0
	524	// width spaces) to ensure that the spaces in the beginning/end of the
	525	// string are underlined too.
	526	a = pango_attr_foreground_new(0x0057, 0x52A9, 0xD614);
	527	a->start_index = 0;
	528	a->end_index = 3;
	529	pango_attr_list_insert(attrs, a);
	530
	531	a = pango_attr_foreground_new(0x0057, 0x52A9, 0xD614);
	532	a->start_index = n + 3;
	533	a->end_index = n + 6;
	534	pango_attr_list_insert(attrs, a);
	535	}
	536	}
	537	if (GetUnderlined())
	538	{
	539	a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
	540	pango_attr_list_insert(attrs, a);
	541	}
	542	if (GetStrikethrough())
	543	{
	544	a = pango_attr_strikethrough_new(true);
	545	pango_attr_list_insert(attrs, a);
	546	}
	547
	548	pango_layout_set_attributes(layout, attrs);
	549	pango_attr_list_unref(attrs);
	550
	551	return true;
	552	}