git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/osx/carbon/font.cpp
	3	// Purpose: wxFont class
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 1998-01-01
	7	// Copyright: (c) Stefan Csomor
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#include "wx/wxprec.h"
	12
	13	#include "wx/font.h"
	14
	15	#ifndef WX_PRECOMP
	16	#include "wx/string.h"
	17	#include "wx/utils.h"
	18	#include "wx/intl.h"
	19	#include "wx/gdicmn.h"
	20	#include "wx/log.h"
	21	#endif
	22
	23	#include "wx/fontutil.h"
	24	#include "wx/graphics.h"
	25	#include "wx/settings.h"
	26	#include "wx/tokenzr.h"
	27
	28	#include "wx/osx/private.h"
	29
	30	#include <map>
	31	#include <string>
	32
	33	class WXDLLEXPORT wxFontRefData: public wxGDIRefData
	34	{
	35	public:
	36
	37	wxFontRefData()
	38	{
	39	Init();
	40	m_info.Init(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
	41	false, wxEmptyString, wxFONTENCODING_DEFAULT);
	42	}
	43
	44	wxFontRefData(const wxFontRefData& data);
	45
	46	wxFontRefData( const wxNativeFontInfo& info ) : m_info(info)
	47	{
	48	Init();
	49	}
	50
	51	wxFontRefData(wxOSXSystemFont font, int size);
	52
	53	#if wxOSX_USE_CORE_TEXT
	54	wxFontRefData( wxUint32 coreTextFontType );
	55	wxFontRefData( CTFontRef font );
	56	wxFontRefData( CTFontDescriptorRef fontdescriptor, int size );
	57	#endif
	58
	59	virtual ~wxFontRefData();
	60
	61	void SetPointSize( int size )
	62	{
	63	if( GetPointSize() != size )
	64	{
	65	m_info.SetPointSize(size);
	66	Free();
	67	}
	68	}
	69
	70	int GetPointSize() const { return m_info.GetPointSize(); }
	71
	72	void SetFamily( wxFontFamily family )
	73	{
	74	if ( m_info.m_family != family )
	75	{
	76	m_info.SetFamily( family );
	77	Free();
	78	}
	79	}
	80
	81	wxFontFamily GetFamily() const { return m_info.GetFamily(); }
	82
	83	void SetStyle( wxFontStyle style )
	84	{
	85	if ( m_info.m_style != style )
	86	{
	87	m_info.SetStyle( style );
	88	Free();
	89	}
	90	}
	91
	92
	93	wxFontStyle GetStyle() const { return m_info.GetStyle(); }
	94
	95	void SetWeight( wxFontWeight weight )
	96	{
	97	if ( m_info.m_weight != weight )
	98	{
	99	m_info.SetWeight( weight );
	100	Free();
	101	}
	102	}
	103
	104
	105	wxFontWeight GetWeight() const { return m_info.GetWeight(); }
	106
	107	void SetUnderlined( bool u )
	108	{
	109	if ( m_info.m_underlined != u )
	110	{
	111	m_info.SetUnderlined( u );
	112	Free();
	113	}
	114	}
	115
	116	bool GetUnderlined() const { return m_info.GetUnderlined(); }
	117
	118	void SetFaceName( const wxString& facename )
	119	{
	120	if ( m_info.m_faceName != facename )
	121	{
	122	m_info.SetFaceName( facename );
	123	Free();
	124	}
	125	}
	126
	127	wxString GetFaceName() const { return m_info.GetFaceName(); }
	128
	129	void SetEncoding( wxFontEncoding encoding )
	130	{
	131	if ( m_info.m_encoding != encoding )
	132	{
	133	m_info.SetEncoding( encoding );
	134	Free();
	135	}
	136	}
	137
	138	wxFontEncoding GetEncoding() const { return m_info.GetEncoding(); }
	139
	140	bool IsFixedWidth() const;
	141
	142	void Free();
	143
	144	void MacFindFont();
	145
	146	protected:
	147	// common part of all ctors
	148	void Init();
	149	#if wxOSX_USE_CORE_TEXT
	150	// void Init( CTFontRef font );
	151	#endif
	152	public:
	153	bool m_fontValid;
	154	#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
	155	// for true theming support we must store the correct font
	156	// information here, as this speeds up and optimizes rendering
	157	ThemeFontID m_macThemeFontID ;
	158	#endif
	159	#if wxOSX_USE_CORE_TEXT
	160	wxCFRef<CTFontRef> m_ctFont;
	161	#endif
	162	#if wxOSX_USE_ATSU_TEXT
	163	void CreateATSUFont();
	164
	165	ATSUStyle m_macATSUStyle ;
	166	#endif
	167	wxCFRef<CGFontRef> m_cgFont;
	168	#if wxOSX_USE_COCOA
	169	WX_NSFont m_nsFont;
	170	#endif
	171	#if wxOSX_USE_IPHONE
	172	WX_UIFont m_uiFont;
	173	#endif
	174	wxNativeFontInfo m_info;
	175	};
	176
	177	#define M_FONTDATA ((wxFontRefData*)m_refData)
	178
	179	wxFontRefData::wxFontRefData(const wxFontRefData& data) : wxGDIRefData()
	180	{
	181	Init();
	182	m_info = data.m_info;
	183	m_fontValid = data.m_fontValid;
	184	#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
	185	m_macThemeFontID = data.m_macThemeFontID;
	186	#endif
	187	#if wxOSX_USE_CORE_TEXT
	188	m_ctFont = data.m_ctFont;
	189	#endif
	190	m_cgFont = data.m_cgFont;
	191	#if wxOSX_USE_ATSU_TEXT
	192	if ( data.m_macATSUStyle != NULL )
	193	{
	194	ATSUCreateStyle(&m_macATSUStyle) ;
	195	ATSUCopyAttributes(data.m_macATSUStyle, m_macATSUStyle);
	196	}
	197	#endif
	198	#if wxOSX_USE_COCOA
	199	m_nsFont = (NSFont*) wxMacCocoaRetain(data.m_nsFont);
	200	#endif
	201	#if wxOSX_USE_IPHONE
	202	m_uiFont = (UIFont*) wxMacCocoaRetain(data.m_uiFont);
	203	#endif
	204
	205	}
	206
	207	// ============================================================================
	208	// implementation
	209	// ============================================================================
	210
	211	// ----------------------------------------------------------------------------
	212	// wxFontRefData
	213	// ----------------------------------------------------------------------------
	214
	215	void wxFontRefData::Init()
	216	{
	217	#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
	218	m_macThemeFontID = kThemeCurrentPortFont ;
	219	#endif
	220	#if wxOSX_USE_ATSU_TEXT
	221	m_macATSUStyle = NULL ;
	222	#endif
	223	#if wxOSX_USE_COCOA
	224	m_nsFont = NULL;
	225	#endif
	226	#if wxOSX_USE_IPHONE
	227	m_uiFont = NULL;
	228	#endif
	229	m_fontValid = false;
	230	}
	231
	232	wxFontRefData::~wxFontRefData()
	233	{
	234	Free();
	235	}
	236
	237	void wxFontRefData::Free()
	238	{
	239	#if wxOSX_USE_CORE_TEXT
	240	m_ctFont.reset();
	241	#endif
	242	m_cgFont.reset();
	243	#if wxOSX_USE_ATSU_TEXT
	244	#if wxOSX_USE_CARBON
	245	m_macThemeFontID = kThemeCurrentPortFont ;
	246	#endif
	247	if ( m_macATSUStyle )
	248	{
	249	::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
	250	m_macATSUStyle = NULL ;
	251	}
	252	#endif
	253	#if wxOSX_USE_COCOA
	254	if (m_nsFont != NULL)
	255	{
	256	wxMacCocoaRelease(m_nsFont);
	257	m_nsFont = NULL;
	258	}
	259	#endif
	260	#if wxOSX_USE_IPHONE
	261	if (m_uiFont != NULL)
	262	{
	263	wxMacCocoaRelease(m_uiFont);
	264	m_uiFont = NULL;
	265	}
	266	#endif
	267	m_fontValid = false;
	268	}
	269
	270	wxFontRefData::wxFontRefData(wxOSXSystemFont font, int size)
	271	{
	272	wxASSERT( font != wxOSX_SYSTEM_FONT_NONE );
	273	Init();
	274
	275	#if wxOSX_USE_CORE_TEXT
	276	{
	277	CTFontUIFontType uifont = kCTFontSystemFontType;
	278	switch( font )
	279	{
	280	case wxOSX_SYSTEM_FONT_NORMAL:
	281	uifont = kCTFontSystemFontType;
	282	break;
	283	case wxOSX_SYSTEM_FONT_BOLD:
	284	uifont = kCTFontEmphasizedSystemFontType;
	285	break;
	286	case wxOSX_SYSTEM_FONT_SMALL:
	287	uifont = kCTFontSmallSystemFontType;
	288	break;
	289	case wxOSX_SYSTEM_FONT_SMALL_BOLD:
	290	uifont = kCTFontSmallEmphasizedSystemFontType;
	291	break;
	292	case wxOSX_SYSTEM_FONT_MINI:
	293	uifont = kCTFontMiniSystemFontType;
	294	break;
	295	case wxOSX_SYSTEM_FONT_MINI_BOLD:
	296	uifont = kCTFontMiniEmphasizedSystemFontType;
	297	break;
	298	case wxOSX_SYSTEM_FONT_LABELS:
	299	uifont = kCTFontLabelFontType;
	300	break;
	301	case wxOSX_SYSTEM_FONT_VIEWS:
	302	uifont = kCTFontViewsFontType;
	303	break;
	304	default:
	305	break;
	306	}
	307	m_ctFont.reset(CTFontCreateUIFontForLanguage( uifont, (CGFloat) size, NULL ));
	308	wxCFRef<CTFontDescriptorRef> descr;
	309	descr.reset( CTFontCopyFontDescriptor( m_ctFont ) );
	310	m_info.Init(descr);
	311	}
	312	#endif
	313	#if wxOSX_USE_ATSU_TEXT
	314	{
	315	#if !wxOSX_USE_CARBON
	316	// not needed outside
	317	ThemeFontID m_macThemeFontID = kThemeSystemFont;
	318	#endif
	319	switch( font )
	320	{
	321	case wxOSX_SYSTEM_FONT_NORMAL:
	322	m_macThemeFontID = kThemeSystemFont;
	323	break;
	324	case wxOSX_SYSTEM_FONT_BOLD:
	325	m_macThemeFontID = kThemeEmphasizedSystemFont;
	326	break;
	327	case wxOSX_SYSTEM_FONT_SMALL:
	328	m_macThemeFontID = kThemeSmallSystemFont;
	329	break;
	330	case wxOSX_SYSTEM_FONT_SMALL_BOLD:
	331	m_macThemeFontID = kThemeSmallEmphasizedSystemFont;
	332	break;
	333	case wxOSX_SYSTEM_FONT_MINI:
	334	m_macThemeFontID = kThemeMiniSystemFont;
	335	break;
	336	case wxOSX_SYSTEM_FONT_MINI_BOLD:
	337	// bold not available under theming
	338	m_macThemeFontID = kThemeMiniSystemFont;
	339	break;
	340	case wxOSX_SYSTEM_FONT_LABELS:
	341	m_macThemeFontID = kThemeLabelFont;
	342	break;
	343	case wxOSX_SYSTEM_FONT_VIEWS:
	344	m_macThemeFontID = kThemeViewsFont;
	345	break;
	346	default:
	347	break;
	348	}
	349	if ( m_info.m_faceName.empty() )
	350	{
	351	Style style ;
	352	FMFontSize fontSize;
	353	Str255 qdFontName ;
	354
	355	GetThemeFont( m_macThemeFontID, GetApplicationScript(), qdFontName, &fontSize, &style );
	356	if ( size != 0 )
	357	fontSize = size;
	358
	359	wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
	360	wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
	361	bool underlined = false;
	362
	363	if ( style & bold )
	364	fontweight = wxFONTWEIGHT_BOLD ;
	365	else
	366	fontweight = wxFONTWEIGHT_NORMAL ;
	367	if ( style & italic )
	368	fontstyle = wxFONTSTYLE_ITALIC ;
	369	if ( style & underline )
	370	underlined = true ;
	371
	372	m_info.Init(fontSize,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
	373	wxMacMakeStringFromPascal( qdFontName ), wxFONTENCODING_DEFAULT);
	374	}
	375	}
	376	#endif
	377	#if wxOSX_USE_COCOA
	378	m_nsFont = wxFont::OSXCreateNSFont( font, &m_info );
	379	#endif
	380	#if wxOSX_USE_IPHONE
	381	m_uiFont = wxFont::OSXCreateUIFont( font, &m_info );
	382	#endif
	383	m_info.EnsureValid();
	384	#if wxOSX_USE_ATSU_TEXT
	385	CreateATSUFont();
	386	#endif
	387
	388	m_fontValid = true;
	389	}
	390
	391	#if wxOSX_USE_ATSU_TEXT
	392	void wxFontRefData::CreateATSUFont()
	393	{
	394	// we try to get as much styles as possible into ATSU
	395
	396	OSStatus status = ::ATSUCreateStyle(&m_macATSUStyle);
	397	wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
	398
	399	ATSUAttributeTag atsuTags[] =
	400	{
	401	kATSUFontTag ,
	402	kATSUSizeTag ,
	403	kATSUVerticalCharacterTag,
	404	kATSUQDBoldfaceTag ,
	405	kATSUQDItalicTag ,
	406	kATSUQDUnderlineTag ,
	407	kATSUQDCondensedTag ,
	408	kATSUQDExtendedTag ,
	409	};
	410	ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
	411	{
	412	sizeof( ATSUFontID ) ,
	413	sizeof( Fixed ) ,
	414	sizeof( ATSUVerticalCharacterType),
	415	sizeof( Boolean ) ,
	416	sizeof( Boolean ) ,
	417	sizeof( Boolean ) ,
	418	sizeof( Boolean ) ,
	419	sizeof( Boolean ) ,
	420	};
	421
	422	Boolean kTrue = true ;
	423	Boolean kFalse = false ;
	424
	425	Fixed atsuSize = IntToFixed( m_info.m_pointSize );
	426	ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
	427	FMFontStyle addQDStyle = m_info.m_atsuAdditionalQDStyles;
	428	ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] =
	429	{
	430	&m_info.m_atsuFontID ,
	431	&atsuSize ,
	432	&kHorizontal,
	433	(addQDStyle & bold) ? &kTrue : &kFalse ,
	434	(addQDStyle & italic) ? &kTrue : &kFalse ,
	435	(addQDStyle & underline) ? &kTrue : &kFalse ,
	436	(addQDStyle & condense) ? &kTrue : &kFalse ,
	437	(addQDStyle & extend) ? &kTrue : &kFalse ,
	438	};
	439
	440	status = ::ATSUSetAttributes(
	441	(ATSUStyle)m_macATSUStyle,
	442	WXSIZEOF(atsuTags),
	443	atsuTags, atsuSizes, atsuValues);
	444
	445	wxASSERT_MSG( status == noErr , wxString::Format(wxT("couldn't modify ATSU style. Status was %d"), (int) status).c_str() );
	446
	447	if ( m_cgFont.get() == NULL )
	448	{
	449	ATSFontRef fontRef = FMGetATSFontRefFromFont(m_info.m_atsuFontID);
	450	m_cgFont.reset( CGFontCreateWithPlatformFont( &fontRef ) );
	451	}
	452	}
	453	#endif
	454
	455	static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
	456	static const CGAffineTransform kSlantTransform = CGAffineTransformMake( 1, 0, tan(DegToRad(11)), 1, 0, 0 );
	457
	458	void wxFontRefData::MacFindFont()
	459	{
	460	if ( m_fontValid )
	461	return;
	462
	463	wxCHECK_RET( m_info.m_pointSize > 0, wxT("Point size should not be zero.") );
	464
	465	m_info.EnsureValid();
	466
	467	#if wxOSX_USE_CORE_TEXT
	468	{
	469	CTFontSymbolicTraits traits = 0;
	470
	471	if (m_info.m_weight == wxFONTWEIGHT_BOLD)
	472	traits \|= kCTFontBoldTrait;
	473	if (m_info.m_style == wxFONTSTYLE_ITALIC \|\| m_info.m_style == wxFONTSTYLE_SLANT)
	474	traits \|= kCTFontItalicTrait;
	475
	476	// use font caching
	477	wxString lookupnameWithSize = wxString::Format( "%s_%u_%d", m_info.m_faceName, traits, m_info.m_pointSize );
	478
	479	static std::map< std::wstring , wxCFRef< CTFontRef > > fontcache ;
	480	m_ctFont = fontcache[ std::wstring(lookupnameWithSize.wc_str()) ];
	481	if ( !m_ctFont )
	482	{
	483	m_ctFont.reset(CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize , NULL ));
	484	if ( m_ctFont.get() == NULL )
	485	{
	486	// TODO try fallbacks according to font type
	487	m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, m_info.m_pointSize , NULL ));
	488	}
	489	else
	490	{
	491	if ( traits != 0 )
	492	{
	493	// attempt native font variant, if not available, fallback to italic emulation mode and remove bold
	494	CTFontRef fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, traits, traits );
	495	if ( fontWithTraits == NULL )
	496	{
	497	CTFontSymbolicTraits remainingTraits = traits;
	498	const CGAffineTransform* remainingTransform = NULL;
	499
	500	if( remainingTraits & kCTFontItalicTrait )
	501	{
	502	remainingTraits &= ~kCTFontItalicTrait;
	503	remainingTransform = &kSlantTransform;
	504	if ( remainingTraits & kCTFontBoldTrait )
	505	{
	506	// first try an emulated oblique with an existing bold font
	507	fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, remainingTransform, remainingTraits, remainingTraits );
	508	if ( fontWithTraits == NULL )
	509	{
	510	// give in on the bold, try native oblique
	511	fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, kCTFontItalicTrait, kCTFontItalicTrait );
	512	}
	513	}
	514	}
	515
	516	if ( fontWithTraits == NULL )
	517	{
	518	fontWithTraits = CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize, remainingTransform );
	519	}
	520
	521	}
	522	if ( fontWithTraits != NULL )
	523	m_ctFont.reset(fontWithTraits);
	524	}
	525	}
	526	}
	527
	528	m_cgFont.reset(CTFontCopyGraphicsFont(m_ctFont, NULL));
	529	}
	530
	531	#endif
	532	#if wxOSX_USE_ATSU_TEXT
	533	CreateATSUFont();
	534	#endif
	535	#if wxOSX_USE_COCOA
	536	m_nsFont = wxFont::OSXCreateNSFont( &m_info );
	537	#endif
	538	#if wxOSX_USE_IPHONE
	539	m_uiFont = wxFont::OSXCreateUIFont( &m_info );
	540	#endif
	541	m_fontValid = true;
	542	}
	543
	544	bool wxFontRefData::IsFixedWidth() const
	545	{
	546	#if wxOSX_USE_CORE_TEXT
	547	CTFontSymbolicTraits traits = CTFontGetSymbolicTraits(m_ctFont);
	548	return (traits & kCTFontMonoSpaceTrait) != 0;
	549	#else
	550	return false;
	551	#endif
	552	}
	553
	554	// ----------------------------------------------------------------------------
	555	// wxFont
	556	// ----------------------------------------------------------------------------
	557
	558	bool wxFont::Create(const wxNativeFontInfo& info)
	559	{
	560	UnRef();
	561
	562	m_refData = new wxFontRefData( info );
	563	RealizeResource();
	564
	565	return true;
	566	}
	567
	568	wxFont::wxFont(wxOSXSystemFont font)
	569	{
	570	m_refData = new wxFontRefData( font, 0 );
	571	}
	572
	573	wxFont::wxFont(const wxString& fontdesc)
	574	{
	575	wxNativeFontInfo info;
	576	if ( info.FromString(fontdesc) )
	577	(void)Create(info);
	578	}
	579
	580	bool wxFont::Create(int pointSize,
	581	wxFontFamily family,
	582	wxFontStyle style,
	583	wxFontWeight weight,
	584	bool underlined,
	585	const wxString& faceNameParam,
	586	wxFontEncoding encoding)
	587	{
	588	UnRef();
	589
	590	wxString faceName = faceNameParam;
	591
	592	if ( faceName.empty() )
	593	{
	594	switch ( family )
	595	{
	596	case wxFONTFAMILY_DEFAULT :
	597	faceName = wxT("Lucida Grande");
	598	break;
	599
	600	case wxFONTFAMILY_SCRIPT :
	601	case wxFONTFAMILY_ROMAN :
	602	case wxFONTFAMILY_DECORATIVE :
	603	faceName = wxT("Times");
	604	break ;
	605
	606	case wxFONTFAMILY_SWISS :
	607	faceName = wxT("Helvetica");
	608	break ;
	609
	610	case wxFONTFAMILY_MODERN :
	611	case wxFONTFAMILY_TELETYPE:
	612	faceName = wxT("Courier");
	613	break ;
	614
	615	default:
	616	faceName = wxT("Times");
	617	break ;
	618	}
	619	}
	620
	621	wxNativeFontInfo info;
	622
	623	info.Init(pointSize, family, style, weight,
	624	underlined, faceName, encoding);
	625
	626	m_refData = new wxFontRefData(info);
	627
	628	return true;
	629	}
	630
	631	wxFont::~wxFont()
	632	{
	633	}
	634
	635	void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info)
	636	{
	637	UnRef();
	638
	639	m_refData = new wxFontRefData( info);
	640	}
	641
	642
	643	bool wxFont::RealizeResource()
	644	{
	645	M_FONTDATA->MacFindFont();
	646
	647	return true;
	648	}
	649
	650	void wxFont::SetEncoding(wxFontEncoding encoding)
	651	{
	652	AllocExclusive();
	653
	654	M_FONTDATA->SetEncoding( encoding );
	655	}
	656
	657	wxGDIRefData *wxFont::CreateGDIRefData() const
	658	{
	659	return new wxFontRefData;
	660	}
	661
	662	wxGDIRefData wxFont::CloneGDIRefData(const wxGDIRefData data) const
	663	{
	664	return new wxFontRefData(static_cast<const wxFontRefData >(data));
	665	}
	666
	667	void wxFont::SetPointSize(int pointSize)
	668	{
	669	if ( M_FONTDATA != NULL && M_FONTDATA->GetPointSize() == pointSize )
	670	return;
	671
	672	AllocExclusive();
	673
	674	M_FONTDATA->SetPointSize( pointSize );
	675	}
	676
	677	void wxFont::SetFamily(wxFontFamily family)
	678	{
	679	AllocExclusive();
	680
	681	M_FONTDATA->SetFamily( family );
	682	}
	683
	684	void wxFont::SetStyle(wxFontStyle style)
	685	{
	686	AllocExclusive();
	687
	688	M_FONTDATA->SetStyle( style );
	689	}
	690
	691	void wxFont::SetWeight(wxFontWeight weight)
	692	{
	693	AllocExclusive();
	694
	695	M_FONTDATA->SetWeight( weight );
	696	}
	697
	698	bool wxFont::SetFaceName(const wxString& faceName)
	699	{
	700	AllocExclusive();
	701
	702	M_FONTDATA->SetFaceName( faceName );
	703
	704	return wxFontBase::SetFaceName(faceName);
	705	}
	706
	707	void wxFont::SetUnderlined(bool underlined)
	708	{
	709	AllocExclusive();
	710
	711	M_FONTDATA->SetUnderlined( underlined );
	712	}
	713
	714	// ----------------------------------------------------------------------------
	715	// accessors
	716	// ----------------------------------------------------------------------------
	717
	718	// TODO: insert checks everywhere for M_FONTDATA == NULL!
	719
	720	int wxFont::GetPointSize() const
	721	{
	722	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	723
	724	return M_FONTDATA->GetPointSize();
	725	}
	726
	727	wxSize wxFont::GetPixelSize() const
	728	{
	729	#if wxUSE_GRAPHICS_CONTEXT
	730	// TODO: consider caching the value
	731	wxGraphicsContext* dc = wxGraphicsContext::CreateFromNative((CGContextRef) NULL);
	732	dc->SetFont((wxFont )this,*wxBLACK);
	733	wxDouble width, height = 0;
	734	dc->GetTextExtent( wxT("g"), &width, &height, NULL, NULL);
	735	delete dc;
	736	return wxSize((int)width, (int)height);
	737	#else
	738	return wxFontBase::GetPixelSize();
	739	#endif
	740	}
	741
	742	bool wxFont::IsFixedWidth() const
	743	{
	744	wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
	745
	746	// cast away constness otherwise lazy font resolution is not possible
	747	const_cast<wxFont *>(this)->RealizeResource();
	748
	749	return M_FONTDATA->IsFixedWidth();
	750	}
	751
	752	wxFontFamily wxFont::DoGetFamily() const
	753	{
	754	return M_FONTDATA->GetFamily();
	755	}
	756
	757	wxFontStyle wxFont::GetStyle() const
	758	{
	759	wxCHECK_MSG( M_FONTDATA != NULL , wxFONTSTYLE_MAX, wxT("invalid font") );
	760
	761	return M_FONTDATA->GetStyle() ;
	762	}
	763
	764	wxFontWeight wxFont::GetWeight() const
	765	{
	766	wxCHECK_MSG( M_FONTDATA != NULL , wxFONTWEIGHT_MAX, wxT("invalid font") );
	767
	768	return M_FONTDATA->GetWeight();
	769	}
	770
	771	bool wxFont::GetUnderlined() const
	772	{
	773	wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
	774
	775	return M_FONTDATA->GetUnderlined();
	776	}
	777
	778	wxString wxFont::GetFaceName() const
	779	{
	780	wxCHECK_MSG( M_FONTDATA != NULL , wxEmptyString , wxT("invalid font") );
	781
	782	return M_FONTDATA->GetFaceName() ;
	783	}
	784
	785	wxFontEncoding wxFont::GetEncoding() const
	786	{
	787	wxCHECK_MSG( M_FONTDATA != NULL , wxFONTENCODING_DEFAULT , wxT("invalid font") );
	788
	789	return M_FONTDATA->GetEncoding() ;
	790	}
	791
	792	#if wxOSX_USE_ATSU_TEXT && wxOSX_USE_CARBON
	793
	794	short wxFont::MacGetFontNum() const
	795	{
	796	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	797
	798	// cast away constness otherwise lazy font resolution is not possible
	799	const_cast<wxFont *>(this)->RealizeResource();
	800
	801	return M_FONTDATA->m_info.m_qdFontFamily;
	802	}
	803
	804	wxByte wxFont::MacGetFontStyle() const
	805	{
	806	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	807
	808	// cast away constness otherwise lazy font resolution is not possible
	809	const_cast<wxFont *>(this)->RealizeResource();
	810
	811	return M_FONTDATA->m_info.m_qdFontStyle;
	812	}
	813
	814	wxUint16 wxFont::MacGetThemeFontID() const
	815	{
	816	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	817
	818	return M_FONTDATA->m_macThemeFontID;
	819	}
	820
	821	#endif
	822
	823	#if wxOSX_USE_ATSU_TEXT
	824	void * wxFont::MacGetATSUStyle() const
	825	{
	826	wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
	827
	828	// cast away constness otherwise lazy font resolution is not possible
	829	const_cast<wxFont *>(this)->RealizeResource();
	830
	831	return M_FONTDATA->m_macATSUStyle;
	832	}
	833
	834	wxUint32 wxFont::MacGetATSUFontID() const
	835	{
	836	wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
	837
	838	// cast away constness otherwise lazy font resolution is not possible
	839	const_cast<wxFont *>(this)->RealizeResource();
	840
	841	return M_FONTDATA->m_info.m_atsuFontID;
	842	}
	843
	844	wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
	845	{
	846	wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
	847
	848	// cast away constness otherwise lazy font resolution is not possible
	849	const_cast<wxFont *>(this)->RealizeResource();
	850
	851	return M_FONTDATA->m_info.m_atsuAdditionalQDStyles;
	852	}
	853	#endif
	854
	855	#if wxOSX_USE_CORE_TEXT
	856
	857	CTFontRef wxFont::OSXGetCTFont() const
	858	{
	859	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	860
	861	// cast away constness otherwise lazy font resolution is not possible
	862	const_cast<wxFont *>(this)->RealizeResource();
	863
	864	return (CTFontRef)(M_FONTDATA->m_ctFont);
	865	}
	866
	867	#endif
	868
	869	#if wxOSX_USE_COCOA_OR_CARBON
	870
	871	CGFontRef wxFont::OSXGetCGFont() const
	872	{
	873	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	874
	875	// cast away constness otherwise lazy font resolution is not possible
	876	const_cast<wxFont *>(this)->RealizeResource();
	877
	878	return (M_FONTDATA->m_cgFont);
	879	}
	880
	881	#endif
	882
	883
	884	#if wxOSX_USE_COCOA
	885
	886	NSFont* wxFont::OSXGetNSFont() const
	887	{
	888	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	889
	890	// cast away constness otherwise lazy font resolution is not possible
	891	const_cast<wxFont *>(this)->RealizeResource();
	892
	893	return (M_FONTDATA->m_nsFont);
	894	}
	895
	896	#endif
	897
	898	#if wxOSX_USE_IPHONE
	899
	900	UIFont* wxFont::OSXGetUIFont() const
	901	{
	902	wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
	903
	904	// cast away constness otherwise lazy font resolution is not possible
	905	const_cast<wxFont *>(this)->RealizeResource();
	906
	907	return (M_FONTDATA->m_uiFont);
	908	}
	909
	910	#endif
	911
	912	const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
	913	{
	914	wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
	915	wxCHECK_MSG( IsOk(), NULL, wxT("invalid font") );
	916
	917	// cast away constness otherwise lazy font resolution is not possible
	918	const_cast<wxFont *>(this)->RealizeResource();
	919
	920	// M_FONTDATA->m_info.InitFromFont(*this);
	921
	922	return &(M_FONTDATA->m_info);
	923	}
	924
	925	// ----------------------------------------------------------------------------
	926	// wxNativeFontInfo
	927	// ----------------------------------------------------------------------------
	928
	929	#if 0 // wxOSX_USE_CORE_TEXT
	930
	931	/* from Core Text Manual Common Operations */
	932
	933	static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
	934	{
	935	CTFontDescriptorRef descriptor = NULL;
	936	CFMutableDictionaryRef attributes;
	937
	938	wxASSERT(iFamilyName != NULL);
	939	// Create a mutable dictionary to hold our attributes.
	940	attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
	941	&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
	942	wxASSERT(attributes != NULL);
	943
	944	if (attributes != NULL) {
	945	// Add a family name to our attributes.
	946	CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
	947
	948
	949	if ( iTraits ) {
	950	CFMutableDictionaryRef traits;
	951	CFNumberRef symTraits;
	952
	953	// Create the traits dictionary.
	954	symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
	955	&iTraits);
	956	wxASSERT(symTraits != NULL);
	957
	958	if (symTraits != NULL) {
	959	// Create a dictionary to hold our traits values.
	960	traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
	961	&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
	962	wxASSERT(traits != NULL);
	963
	964	if (traits != NULL) {
	965	// Add the symbolic traits value to the traits dictionary.
	966	CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
	967
	968	// Add the traits attribute to our attributes.
	969	CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
	970	CFRelease(traits);
	971	}
	972	CFRelease(symTraits);
	973	}
	974	}
	975	// Create the font descriptor with our attributes
	976	descriptor = CTFontDescriptorCreateWithAttributes(attributes);
	977	wxASSERT(descriptor != NULL);
	978
	979	CFRelease(attributes);
	980	}
	981	// Return our font descriptor.
	982	return descriptor ;
	983	}
	984
	985	#endif
	986
	987	void wxNativeFontInfo::Init()
	988	{
	989	#if wxOSX_USE_ATSU_TEXT
	990	m_atsuFontID = 0 ;
	991	m_atsuAdditionalQDStyles = 0;
	992	m_atsuFontValid = false;
	993	#if wxOSX_USE_CARBON
	994	m_qdFontStyle = 0;
	995	m_qdFontFamily = 0;
	996	#endif
	997	#endif
	998	m_pointSize = 0;
	999	m_family = wxFONTFAMILY_DEFAULT;
	1000	m_style = wxFONTSTYLE_NORMAL;
	1001	m_weight = wxFONTWEIGHT_NORMAL;
	1002	m_underlined = false;
	1003	m_faceName.clear();
	1004	m_encoding = wxFont::GetDefaultEncoding();
	1005	m_descriptorValid = false;
	1006	}
	1007
	1008	#if wxOSX_USE_CORE_TEXT
	1009	void wxNativeFontInfo::Init(CTFontDescriptorRef descr)
	1010	{
	1011	Init();
	1012
	1013	wxCFRef< CFNumberRef > sizevalue( (CFNumberRef) CTFontDescriptorCopyAttribute( descr, kCTFontSizeAttribute ) );
	1014	float fsize;
	1015	if ( CFNumberGetValue( sizevalue , kCFNumberFloatType , &fsize ) )
	1016	m_pointSize = (int)( fsize + 0.5 );
	1017
	1018	wxCFRef< CFDictionaryRef > traitsvalue( (CFDictionaryRef) CTFontDescriptorCopyAttribute( descr, kCTFontTraitsAttribute ) );
	1019	CTFontSymbolicTraits traits;
	1020	if ( CFNumberGetValue((CFNumberRef) CFDictionaryGetValue(traitsvalue,kCTFontSymbolicTrait),kCFNumberIntType,&traits) )
	1021	{
	1022	if ( traits & kCTFontItalicTrait )
	1023	m_style = wxFONTSTYLE_ITALIC;
	1024	if ( traits & kCTFontBoldTrait )
	1025	m_weight = wxFONTWEIGHT_BOLD ;
	1026	}
	1027
	1028	wxCFStringRef familyName( (CFStringRef) CTFontDescriptorCopyAttribute(descr, kCTFontFamilyNameAttribute));
	1029	m_faceName = familyName.AsString();
	1030	}
	1031	#endif
	1032
	1033	void wxNativeFontInfo::EnsureValid()
	1034	{
	1035	if ( m_descriptorValid )
	1036	return;
	1037
	1038	#if wxOSX_USE_ATSU_TEXT
	1039	if ( !m_atsuFontValid )
	1040	{
	1041	#if !wxOSX_USE_CARBON
	1042	// not needed outside
	1043	wxInt16 m_qdFontFamily;
	1044	wxInt16 m_qdFontStyle;
	1045	#endif
	1046	wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
	1047	ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
	1048	if ( atsfamily == (ATSFontFamilyRef) -1 )
	1049	{
	1050	wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
	1051	m_qdFontFamily = GetAppFont();
	1052	}
	1053	else
	1054	{
	1055	m_qdFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
	1056	}
	1057
	1058	m_qdFontStyle = 0;
	1059	if (m_weight == wxFONTWEIGHT_BOLD)
	1060	m_qdFontStyle \|= bold;
	1061	if (m_style == wxFONTSTYLE_ITALIC \|\| m_style == wxFONTSTYLE_SLANT)
	1062	m_qdFontStyle \|= italic;
	1063	if (m_underlined)
	1064	m_qdFontStyle \|= underline;
	1065
	1066
	1067	// we try to get as much styles as possible into ATSU
	1068
	1069	// ATSUFontID and FMFont are equivalent
	1070	FMFontStyle intrinsicStyle = 0 ;
	1071	OSStatus status = FMGetFontFromFontFamilyInstance( m_qdFontFamily , m_qdFontStyle , (FMFont*)&m_atsuFontID , &intrinsicStyle);
	1072	if ( status != noErr )
	1073	{
	1074	wxFAIL_MSG( wxT("couldn't get an ATSUFont from font family") );
	1075	}
	1076	m_atsuAdditionalQDStyles = m_qdFontStyle & (~intrinsicStyle );
	1077	m_atsuFontValid = true;
	1078	}
	1079	#endif
	1080	m_descriptorValid = true;
	1081	}
	1082
	1083	void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
	1084	{
	1085	Init();
	1086	#if wxOSX_USE_ATSU_TEXT
	1087	m_atsuFontValid = info.m_atsuFontValid;
	1088	m_atsuFontID = info.m_atsuFontID ;
	1089	m_atsuAdditionalQDStyles = info.m_atsuAdditionalQDStyles;
	1090	#if wxOSX_USE_CARBON
	1091	m_qdFontFamily = info.m_qdFontFamily;
	1092	m_qdFontStyle = info.m_qdFontStyle;
	1093	#endif
	1094	#endif
	1095	m_pointSize = info.m_pointSize;
	1096	m_family = info.m_family;
	1097	m_style = info.m_style;
	1098	m_weight = info.m_weight;
	1099	m_underlined = info.m_underlined;
	1100	m_faceName = info.m_faceName;
	1101	m_encoding = info.m_encoding;
	1102	m_descriptorValid = info.m_descriptorValid;
	1103	}
	1104
	1105	void wxNativeFontInfo::Init(int size,
	1106	wxFontFamily family,
	1107	wxFontStyle style,
	1108	wxFontWeight weight,
	1109	bool underlined,
	1110	const wxString& faceName,
	1111	wxFontEncoding encoding)
	1112	{
	1113	Init();
	1114
	1115	// We should use the default font size if the special value wxDEFAULT is
	1116	// specified and we also handle -1 as a synonym for wxDEFAULT for
	1117	// compatibility with wxGTK (see #12541).
	1118	//
	1119	// Notice that we rely on the fact that wxNORMAL_FONT itself is not
	1120	// initialized using this ctor, but from native font info.
	1121	m_pointSize = size == -1 \|\| size == wxDEFAULT
	1122	? wxNORMAL_FONT->GetPointSize()
	1123	: size;
	1124	m_family = family;
	1125	m_style = style;
	1126	m_weight = weight;
	1127	m_underlined = underlined;
	1128	m_faceName = faceName;
	1129	if ( encoding == wxFONTENCODING_DEFAULT )
	1130	encoding = wxFont::GetDefaultEncoding();
	1131	m_encoding = encoding;
	1132
	1133	}
	1134
	1135	void wxNativeFontInfo::Free()
	1136	{
	1137	#if wxOSX_USE_ATSU_TEXT
	1138	m_atsuFontID = 0 ;
	1139	m_atsuAdditionalQDStyles = 0;
	1140	m_atsuFontValid = false;
	1141	#endif
	1142	m_descriptorValid = false;
	1143	}
	1144
	1145	bool wxNativeFontInfo::FromString(const wxString& s)
	1146	{
	1147	long l;
	1148
	1149	wxStringTokenizer tokenizer(s, wxT(";"));
	1150
	1151	wxString token = tokenizer.GetNextToken();
	1152	//
	1153	// Ignore the version for now
	1154	//
	1155
	1156	token = tokenizer.GetNextToken();
	1157	if ( !token.ToLong(&l) )
	1158	return false;
	1159	m_pointSize = (int)l;
	1160
	1161	token = tokenizer.GetNextToken();
	1162	if ( !token.ToLong(&l) )
	1163	return false;
	1164	m_family = (wxFontFamily)l;
	1165
	1166	token = tokenizer.GetNextToken();
	1167	if ( !token.ToLong(&l) )
	1168	return false;
	1169	m_style = (wxFontStyle)l;
	1170
	1171	token = tokenizer.GetNextToken();
	1172	if ( !token.ToLong(&l) )
	1173	return false;
	1174	m_weight = (wxFontWeight)l;
	1175
	1176	token = tokenizer.GetNextToken();
	1177	if ( !token.ToLong(&l) )
	1178	return false;
	1179	m_underlined = l != 0;
	1180
	1181	m_faceName = tokenizer.GetNextToken();
	1182
	1183	#ifndef __WXMAC__
	1184	if( !faceName )
	1185	return false;
	1186	#endif
	1187
	1188	token = tokenizer.GetNextToken();
	1189	if ( !token.ToLong(&l) )
	1190	return false;
	1191	m_encoding = (wxFontEncoding)l;
	1192
	1193	return true;
	1194	}
	1195
	1196	wxString wxNativeFontInfo::ToString() const
	1197	{
	1198	wxString s;
	1199
	1200	s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
	1201	0, // version
	1202	m_pointSize,
	1203	m_family,
	1204	(int)m_style,
	1205	(int)m_weight,
	1206	m_underlined,
	1207	m_faceName.GetData(),
	1208	(int)m_encoding);
	1209
	1210	return s;
	1211	}
	1212
	1213	int wxNativeFontInfo::GetPointSize() const
	1214	{
	1215	return m_pointSize;
	1216	}
	1217
	1218	wxFontStyle wxNativeFontInfo::GetStyle() const
	1219	{
	1220	return m_style;
	1221	}
	1222
	1223	wxFontWeight wxNativeFontInfo::GetWeight() const
	1224	{
	1225	return m_weight;
	1226	}
	1227
	1228	bool wxNativeFontInfo::GetUnderlined() const
	1229	{
	1230	return m_underlined;
	1231	}
	1232
	1233	wxString wxNativeFontInfo::GetFaceName() const
	1234	{
	1235	return m_faceName;
	1236	}
	1237
	1238	wxFontFamily wxNativeFontInfo::GetFamily() const
	1239	{
	1240	return m_family;
	1241	}
	1242
	1243	wxFontEncoding wxNativeFontInfo::GetEncoding() const
	1244	{
	1245	return m_encoding;
	1246	}
	1247
	1248	bool wxNativeFontInfo::GetStrikethrough() const
	1249	{
	1250	return false;
	1251	}
	1252
	1253
	1254	// changing the font descriptor
	1255
	1256	void wxNativeFontInfo::SetPointSize(int pointsize)
	1257	{
	1258	if ( m_pointSize != pointsize )
	1259	{
	1260	m_pointSize = pointsize;
	1261	Free();
	1262	}
	1263	}
	1264
	1265	void wxNativeFontInfo::SetStyle(wxFontStyle style_)
	1266	{
	1267	if ( m_style != style_ )
	1268	{
	1269	m_style = style_;
	1270	Free();
	1271	}
	1272	}
	1273
	1274	void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
	1275	{
	1276	if ( m_weight != weight_ )
	1277	{
	1278	m_weight = weight_;
	1279	Free();
	1280	}
	1281	}
	1282
	1283	void wxNativeFontInfo::SetUnderlined(bool underlined_)
	1284	{
	1285	if ( m_underlined != underlined_ )
	1286	{
	1287	m_underlined = underlined_;
	1288	Free();
	1289	}
	1290	}
	1291
	1292	bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
	1293	{
	1294	if ( m_faceName != facename_ )
	1295	{
	1296	m_faceName = facename_;
	1297	Free();
	1298	}
	1299	return true;
	1300	}
	1301
	1302	void wxNativeFontInfo::SetFamily(wxFontFamily family_)
	1303	{
	1304	if ( m_family != family_ )
	1305	{
	1306	m_family = family_;
	1307	Free();
	1308	}
	1309	}
	1310
	1311	void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
	1312	{
	1313	if ( encoding_ == wxFONTENCODING_DEFAULT )
	1314	encoding_ = wxFont::GetDefaultEncoding();
	1315	m_encoding = encoding_;
	1316	// not reflected in native descriptors
	1317	}
	1318
	1319	void wxNativeFontInfo::SetStrikethrough(bool WXUNUSED(strikethrough))
	1320	{
	1321	}
	1322
	1323