git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/fontdlg.cpp

1 /////////////////////////////////////////////////////////////////////////////

2 // Name: src/osx/carbon/fontdlg.cpp

3 // Purpose: wxFontDialog class for carbon 10.2+.

4 // Author: Ryan Norton

5 // Modified by:

6 // Created: 1998-01-01

7 // Copyright: (c) Ryan Norton

8 // Licence: wxWindows licence

9 /////////////////////////////////////////////////////////////////////////////

11 // ===========================================================================

12 // declarations

13 // ===========================================================================

15 // ---------------------------------------------------------------------------

16 // headers

17 // ---------------------------------------------------------------------------

19 // For compilers that support precompilation, includes "wx.h".

20 #include "wx/wxprec.h"

22 #if wxUSE_FONTDLG

24 #ifdef __BORLANDC__

25 #pragma hdrstop

26 #endif

28 #ifndef WX_PRECOMP

29 #include "wx/intl.h"

30 #include "wx/crt.h"

31 #include "wx/dcclient.h"

32 #include "wx/frame.h"

33 #include "wx/textctrl.h"

34 #include "wx/listbox.h"

35 #include "wx/checkbox.h"

36 #include "wx/choice.h"

37 #include "wx/sizer.h"

38 #include "wx/stattext.h"

39 #include "wx/button.h"

40 #endif

42 #include "wx/fontdlg.h"

43 #include "wx/fontutil.h"

44 #include "wx/modalhook.h"

46 #if wxOSX_USE_EXPERIMENTAL_FONTDIALOG

48 IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)

50 #include "wx/osx/private.h"

52 // ---------------------------------------------------------------------------

53 // wxFontDialog

54 // ---------------------------------------------------------------------------

56 #if wxOSX_USE_CARBON

58 static const EventTypeSpec eventList[] =

59 {

60 { kEventClassFont, kEventFontSelection } ,

61 } ;

64 pascal OSStatus

 wxMacCarbonFontPanelHandler(EventHandlerCallRef WXUNUSED(nextHandler),

66 EventRef event,

67 void *userData)

68 {

69 OSStatus result = eventNotHandledErr ;

70 wxFontDialog *fontdialog = (wxFontDialog*) userData ;

     wxFontData& fontdata= fontdialog->GetFontData() ;

73 wxMacCarbonEvent cEvent( event );

     switch(cEvent.GetKind())

75 {

76 case kEventFontSelection :

77 {

78 bool setup = false ;

79 #if wxOSX_USE_CORE_TEXT

80 if ( !setup )

81 {

82 CTFontDescriptorRef descr;

                 if ( cEvent.GetParameter<CTFontDescriptorRef>( kEventParamCTFontDescriptor, typeCTFontDescriptorRef, &descr ) == noErr )

84 {

85 wxFont font;

86 wxNativeFontInfo fontinfo;

87 fontinfo.Init(descr);

88 font.Create(fontinfo);

89 fontdata.SetChosenFont( font ) ;

90 setup = true;

91 }

92 }

93 #endif

94 #if wxOSX_USE_ATSU_TEXT

95 ATSUFontID fontId = 0 ;

             if ( !setup && (cEvent.GetParameter<ATSUFontID>(kEventParamATSUFontID, &fontId) == noErr) )

97 {

                 FMFontStyle fontStyle = cEvent.GetParameter<FMFontStyle>(kEventParamFMFontStyle);

                 FMFontSize fontSize = cEvent.GetParameter<FMFontSize>(kEventParamFMFontSize);

100

101 CFStringRef cfName = NULL;

102 #if 1

                 FMFontFamily fontFamily = cEvent.GetParameter<FMFontFamily>(kEventParamFMFontFamily);

104 ATSFontFamilyRef atsfontfamilyref = FMGetATSFontFamilyRefFromFontFamily( fontFamily ) ;

                 OSStatus err = ATSFontFamilyGetName( atsfontfamilyref , kATSOptionFlagsDefault , &cfName ) ;

106 if ( err != noErr )

107 {

108 wxFAIL_MSG("ATSFontFamilyGetName failed");

109 }

110 #else

111 // we don't use the ATSU naming anymore

112 ByteCount actualLength = 0;

113 char *c = NULL;

                 OSStatus err = ATSUFindFontName(fontId , kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,

                                                 kFontNoLanguageCode , 0 , NULL , &actualLength , NULL );

116 if ( err == noErr)

117 {

118 actualLength += 1 ;

                     char *c = (char*)malloc( actualLength );

                     err = ATSUFindFontName(fontId, kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,

                                            kFontNoLanguageCode, actualLength, c , NULL, NULL);

                     cfName = CFStringCreateWithCharacters(NULL, (UniChar*) c, (actualLength-1) >> 1);

123 }

124 else

125 {

                     err = ATSUFindFontName(fontId , kFontFamilyName, kFontNoPlatformCode, kFontNoScriptCode,

                                            kFontNoLanguageCode , 0 , NULL , &actualLength , NULL );

128 if ( err == noErr )

129 {

130 actualLength += 1 ;

                         c = (char*)malloc(actualLength);

                         err = ATSUFindFontName(fontId, kFontFamilyName, kFontNoPlatformCode, kFontNoScriptCode,

                                                kFontNoLanguageCode, actualLength, c , NULL, NULL);

                         c[actualLength-1] = 0;

                         cfName = CFStringCreateWithCString(NULL, c, kCFStringEncodingMacRoman );

136 }

137 }

138 if ( c!=NULL )

139 free(c);

140 #endif

141 if ( cfName!=NULL )

142 {

                     fontdata.m_chosenFont.SetFaceName(wxCFStringRef(cfName).AsString(wxLocale::GetSystemEncoding()));

                     fontdata.m_chosenFont.SetPointSize(fontSize);

                     fontdata.m_chosenFont.SetStyle(fontStyle & italic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL);

                     fontdata.m_chosenFont.SetUnderlined((fontStyle & underline)!=0);

                     fontdata.m_chosenFont.SetWeight(fontStyle & bold ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL);

148 }

149 }

150 #endif // wxOSX_USE_ATSU_TEXT

151

152 // retrieving the color

153 RGBColor fontColor ;

             if ( cEvent.GetParameter<RGBColor>(kEventParamFontColor, &fontColor) == noErr )

155 {

156 fontdata.m_fontColour = fontColor;

157 }

158 else

159 {

160 CFDictionaryRef dict ;

                 if ( cEvent.GetParameter<CFDictionaryRef>(kEventParamDictionary, &dict) == noErr )

162 {

163 CFDictionaryRef attributesDict ;

                     if ( CFDictionaryGetValueIfPresent(dict, kFontPanelAttributesKey, (const void **)&attributesDict) )

165 {

166 CFDataRef tagsData;

167 CFDataRef sizesData;

168 CFDataRef valuesData;

                         if ( CFDictionaryGetValueIfPresent(attributesDict, kFontPanelAttributeTagsKey, (const void **)&tagsData) &&

                             CFDictionaryGetValueIfPresent(attributesDict, kFontPanelAttributeSizesKey, (const void **)&sizesData) &&

                             CFDictionaryGetValueIfPresent(attributesDict, kFontPanelAttributeValuesKey, (const void **)&valuesData) )

172 {

                             ItemCount count = CFDataGetLength(tagsData)/sizeof(ATSUAttributeTag);

                             ATSUAttributeTag *tagPtr = (ATSUAttributeTag *)CFDataGetBytePtr(tagsData);

                             ByteCount *sizePtr = (ByteCount *)CFDataGetBytePtr(sizesData);

                             UInt32 *bytePtr = (UInt32*)CFDataGetBytePtr(valuesData);

177 ATSUAttributeValuePtr valuesPtr = bytePtr ;

                             for ( ItemCount i = 0 ; i < count ; ++i)

179 {

                                 if ( tagPtr[i] == kATSUColorTag && sizePtr[i] == sizeof(RGBColor))

181 {

182 fontdata.m_fontColour = *(RGBColor *)valuesPtr;

183 break ;

184 }

                                 bytePtr = (UInt32*)( (UInt8*)bytePtr + sizePtr[i]);

186 }

187 }

188 }

189 }

190 }

191 }

192 break ;

193 }

194

195 return result ;

196 }

197

198 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacCarbonFontPanelHandler )

199 #endif

200

201 wxFontDialog::wxFontDialog()

202 {

203 }

204

 wxFontDialog::wxFontDialog(wxWindow *parent)

206 {

207 Create(parent);

208 }

209

 wxFontDialog::wxFontDialog(wxWindow *parent, const wxFontData&  data)

211 {

212 Create(parent, data);

213 }

214

215 wxFontDialog::~wxFontDialog()

216 {

217 }

218

 bool wxFontDialog::Create(wxWindow *WXUNUSED(parent))

220 {

221 return true ;

222 }

223

 bool wxFontDialog::Create(wxWindow *parent, const wxFontData& data)

225 {

226 m_fontData = data;

227 return Create(parent) ;

228 }

229

 int wxFontDialog::ShowModal()

231 {

232 WX_HOOK_MODAL_DIALOG();

233

234 #if wxOSX_USE_CARBON

235

236 OSStatus err ;

237 wxFont font = *wxNORMAL_FONT ;

     if ( m_fontData.m_initialFont.IsOk() )

239 {

240 font = m_fontData.m_initialFont ;

241 }

242

243 bool setup = false;

244 #if wxOSX_USE_CORE_TEXT

245 if ( !setup )

246 {

         CTFontDescriptorRef descr = (CTFontDescriptorRef) CTFontCopyFontDescriptor( (CTFontRef) font.OSXGetCTFont() );

         err = SetFontInfoForSelection (kFontSelectionCoreTextType,1, &descr , NULL);

249 CFRelease( descr );

250 setup = true;

251 }

252 #endif

253 #if wxOSX_USE_ATSU_TEXT

254 if ( !setup )

255 {

         ATSUStyle style = (ATSUStyle)font.MacGetATSUStyle();

         err = SetFontInfoForSelection (kFontSelectionATSUIType,1, &style , NULL);

258 setup = true;

259 }

260 #endif

261 // just clicking on ENTER will not send us any font setting event, therefore we have to make sure

262 // that field is already correct

263 m_fontData.m_chosenFont = font ;

264

265 EventHandlerRef handler ;

266

     err = InstallApplicationEventHandler( GetwxMacCarbonFontPanelHandlerUPP(), GetEventTypeCount(eventList), eventList, this , &handler );

268

269 if ( !FPIsFontPanelVisible() )

270 FPShowHideFontPanel();

271 #endif

272 wxDialog::OSXBeginModalDialog();

     int retval = RunMixedFontDialog(this);

274 wxDialog::OSXEndModalDialog();

275 #if wxOSX_USE_CARBON

276 ::RemoveEventHandler(handler);

277 #endif

278

279 return retval ;

280 }

281

282 #else

283

284 #if !USE_NATIVE_FONT_DIALOG_FOR_MACOSX

285

286 #undef wxFontDialog

287

288 #include "wx/osx/fontdlg.h"

289

290 #include "wx/fontenum.h"

291 #include "wx/colordlg.h"

292 #include "wx/spinctrl.h"

293

294 // ---------------------------------------------------------------------------

295 // wxFontDialog stub for mac OS's without a native font dialog

296 // ---------------------------------------------------------------------------

297

 static const wxChar *FontFamilyIntToString(int family);

 static int FontFamilyStringToInt(const wxChar *family);

300

301

302 //-----------------------------------------------------------------------------

303 // helper class - wxFontPreviewCtrl

304 //-----------------------------------------------------------------------------

305

306 class WXDLLEXPORT wxFontPreviewCtrl : public wxWindow

307 {

308 public:

     wxFontPreviewCtrl(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& sz = wxDefaultSize, long style = 0) :

         wxWindow(parent, id, pos, sz, style)

311 {

312 SetBackgroundColour(*wxWHITE);

313 }

314

315 private:

     void OnPaint(wxPaintEvent& event);

317 DECLARE_EVENT_TABLE()

318 };

319

320 BEGIN_EVENT_TABLE(wxFontPreviewCtrl, wxWindow)

     EVT_PAINT(wxFontPreviewCtrl::OnPaint)

322 END_EVENT_TABLE()

323

 void wxFontPreviewCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))

325 {

326 wxPaintDC dc(this);

327

328 wxSize size = GetSize();

329 wxFont font = GetFont();

330

     if ( font.IsOk() )

332 {

333 dc.SetFont(font);

334 // Calculate vertical centre

         long w = 0, h = 0;

         dc.GetTextExtent( wxT("X"), &w, &h);

         dc.SetTextForeground(GetForegroundColour());

         dc.SetClippingRegion(2, 2, size.x-4, size.y-4);

         dc.DrawText(_("ABCDEFGabcdefg12345"),

                      10, size.y/2 - h/2);

341 dc.DestroyClippingRegion();

342 }

343 }

344

345 /*

346 * A control for displaying a small preview of a colour or bitmap

347 */

348

349 class wxFontColourSwatchCtrl: public wxControl

350 {

351 DECLARE_CLASS(wxFontColourSwatchCtrl)

352 public:

     wxFontColourSwatchCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);

354 virtual ~wxFontColourSwatchCtrl();

355

     void OnPaint(wxPaintEvent& event);

     void OnMouseEvent(wxMouseEvent& event);

358

     void SetColour(const wxColour& colour) { m_colour = colour; SetBackgroundColour(m_colour); }

360

     wxColour& GetColour() { return m_colour; }

362

     virtual wxSize DoGetBestSize() const { return GetSize(); }

364

365 protected:

366 wxColour m_colour;

367

368 DECLARE_EVENT_TABLE()

369 };

370

371 /*

372 * A control for displaying a small preview of a colour or bitmap

373 */

374

375 BEGIN_EVENT_TABLE(wxFontColourSwatchCtrl, wxControl)

     EVT_MOUSE_EVENTS(wxFontColourSwatchCtrl::OnMouseEvent)

377 END_EVENT_TABLE()

378

379 IMPLEMENT_CLASS(wxFontColourSwatchCtrl, wxControl)

380

 wxFontColourSwatchCtrl::wxFontColourSwatchCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style):

     wxControl(parent, id, pos, size, style)

383 {

384 SetColour(* wxWHITE);

385 SetBackgroundStyle(wxBG_STYLE_COLOUR);

386 }

387

388 wxFontColourSwatchCtrl::~wxFontColourSwatchCtrl()

389 {

390 }

391

 void wxFontColourSwatchCtrl::OnMouseEvent(wxMouseEvent& event)

393 {

     if (event.LeftDown())

395 {

396 wxWindow* parent = GetParent();

         while (parent != NULL && !parent->IsKindOf(CLASSINFO(wxDialog)) && !parent->IsKindOf(CLASSINFO(wxFrame)))

398 parent = parent->GetParent();

399

400 wxColourData data;

         data.SetChooseFull(true);

402 data.SetColour(m_colour);

         wxColourDialog *dialog = new wxColourDialog(parent, &data);

404 // Crashes on wxMac (no m_peer)

405 #ifndef __WXMAC__

         dialog->SetTitle(_("Background colour"));

407 #endif

         if (dialog->ShowModal() == wxID_OK)

409 {

410 wxColourData retData = dialog->GetColourData();

411 m_colour = retData.GetColour();

412 SetBackgroundColour(m_colour);

413 }

414 dialog->Destroy();

415 Refresh();

416

         wxCommandEvent event(wxEVT_BUTTON, GetId());

418 HandleWindowEvent(event);

419 }

420 }

421

422 /*!

423 * wxFontDialog type definition

424 */

425

426 IMPLEMENT_DYNAMIC_CLASS( wxFontDialog, wxDialog )

427

428 /*!

429 * wxFontDialog event table definition

430 */

431

432 BEGIN_EVENT_TABLE( wxFontDialog, wxDialog )

     EVT_LISTBOX( wxID_FONTDIALOG_FACENAME, wxFontDialog::OnFontdialogFacenameSelected )

     EVT_SPINCTRL( wxID_FONTDIALOG_FONTSIZE, wxFontDialog::OnFontdialogFontsizeUpdated )

     EVT_TEXT( wxID_FONTDIALOG_FONTSIZE, wxFontDialog::OnFontdialogFontsizeTextUpdated )

     EVT_CHECKBOX( wxID_FONTDIALOG_BOLD, wxFontDialog::OnFontdialogBoldClick )

     EVT_CHECKBOX( wxID_FONTDIALOG_ITALIC, wxFontDialog::OnFontdialogItalicClick )

     EVT_CHECKBOX( wxID_FONTDIALOG_UNDERLINED, wxFontDialog::OnFontdialogUnderlinedClick )

     EVT_BUTTON( wxID_OK, wxFontDialog::OnOkClick )

     EVT_BUTTON(wxID_FONTDIALOG_COLOUR, wxFontDialog::OnColourChanged)

441 END_EVENT_TABLE()

442

443 /*!

444 * wxFontDialog constructors

445 */

446

447 wxFontDialog::wxFontDialog( )

448 {

449 m_dialogParent = NULL;

450 }

451

 wxFontDialog::wxFontDialog(wxWindow* parent, const wxFontData& fontData)

453 {

454 m_dialogParent = NULL;

455

456 Create(parent, fontData);

457 }

458

459 wxFontDialog::~wxFontDialog()

460 {

461 // empty

462 }

463

464 /*!

465 * wxFontDialog creator

466 */

467

 bool wxFontDialog::Create(wxWindow* parent, const wxFontData& fontData)

469 {

470 m_fontData = fontData;

471 m_suppressUpdates = false;

472

     wxString caption = _("Font");

474

475 m_facenameCtrl = NULL;

476 m_sizeCtrl = NULL;

477 m_boldCtrl = NULL;

478 m_italicCtrl = NULL;

479 m_underlinedCtrl = NULL;

480 m_colourCtrl = NULL;

481 m_previewCtrl = NULL;

482

483 InitializeFont();

484

     SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);

     wxDialog::Create( parent, wxID_ANY, caption, wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER );

487

488 CreateControls();

     GetSizer()->Fit(this);

     GetSizer()->SetSizeHints(this);

491 Centre();

492

493 return true;

494 }

495

496 /*!

497 * Control creation for wxFontDialog

498 */

499

 void wxFontDialog::CreateControls()

501 {

502 wxFontDialog* itemDialog1 = this;

503

     wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);

505 itemDialog1->SetSizer(itemBoxSizer2);

506

     wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxVERTICAL);

     itemBoxSizer2->Add(itemBoxSizer3, 1, wxGROW|wxALL, 5);

509

     wxFlexGridSizer* itemFlexGridSizer4 = new wxFlexGridSizer(6, 2, 10, 0);

     itemFlexGridSizer4->AddGrowableRow(4);

     itemFlexGridSizer4->AddGrowableCol(1);

     itemBoxSizer3->Add(itemFlexGridSizer4, 1, wxGROW|wxALL, 5);

514

     wxStaticText* itemStaticText5 = new wxStaticText( itemDialog1, wxID_STATIC, _("Font:"), wxDefaultPosition, wxDefaultSize, 0 );

     itemFlexGridSizer4->Add(itemStaticText5, 0, wxALIGN_RIGHT|wxALIGN_TOP|wxALL, 5);

517

     wxBoxSizer* itemBoxSizer6 = new wxBoxSizer(wxVERTICAL);

     itemFlexGridSizer4->Add(itemBoxSizer6, 0, wxGROW, 5);

520

521 wxString* m_facenameCtrlStrings = NULL;

     m_facenameCtrl = new wxListBox( itemDialog1, wxID_FONTDIALOG_FACENAME, wxDefaultPosition, wxSize(320, 100), 0, m_facenameCtrlStrings, wxLB_SINGLE );

     itemBoxSizer6->Add(m_facenameCtrl, 0, wxGROW|wxALL, 5);

524

     wxStaticText* itemStaticText8 = new wxStaticText( itemDialog1, wxID_STATIC, _("Size:"), wxDefaultPosition, wxDefaultSize, 0 );

     itemFlexGridSizer4->Add(itemStaticText8, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);

527

     m_sizeCtrl = new wxSpinCtrl( itemDialog1, wxID_FONTDIALOG_FONTSIZE, wxT("12"), wxDefaultPosition, wxSize(60, -1), wxSP_ARROW_KEYS, 1, 300, 12 );

     m_sizeCtrl->SetHelpText(_("The font size in points."));

530 if (ShowToolTips())

         m_sizeCtrl->SetToolTip(_("The font size in points."));

     itemFlexGridSizer4->Add(m_sizeCtrl, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);

533

     wxStaticText* itemStaticText10 = new wxStaticText( itemDialog1, wxID_STATIC, _("Style:"), wxDefaultPosition, wxDefaultSize, 0 );

     itemFlexGridSizer4->Add(itemStaticText10, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5);

536

     wxBoxSizer* itemBoxSizer11 = new wxBoxSizer(wxHORIZONTAL);

     itemFlexGridSizer4->Add(itemBoxSizer11, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);

539

     m_boldCtrl = new wxCheckBox( itemDialog1, wxID_FONTDIALOG_BOLD, _("Bold"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );

     m_boldCtrl->SetValue(false);

     m_boldCtrl->SetHelpText(_("Check to make the font bold."));

543 if (ShowToolTips())

         m_boldCtrl->SetToolTip(_("Check to make the font bold."));

     itemBoxSizer11->Add(m_boldCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

546

     m_italicCtrl = new wxCheckBox( itemDialog1, wxID_FONTDIALOG_ITALIC, _("Italic"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );

     m_italicCtrl->SetValue(false);

     m_italicCtrl->SetHelpText(_("Check to make the font italic."));

550 if (ShowToolTips())

         m_italicCtrl->SetToolTip(_("Check to make the font italic."));

     itemBoxSizer11->Add(m_italicCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

553

     if (m_fontData.GetEnableEffects())

555 {

         m_underlinedCtrl = new wxCheckBox( itemDialog1, wxID_FONTDIALOG_UNDERLINED, _("Underlined"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );

         m_underlinedCtrl->SetValue(false);

         m_underlinedCtrl->SetHelpText(_("Check to make the font underlined."));

559 if (ShowToolTips())

             m_underlinedCtrl->SetToolTip(_("Check to make the font underlined."));

         itemBoxSizer11->Add(m_underlinedCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

562 }

563

     if (m_fontData.GetEnableEffects())

565 {

         wxStaticText* itemStaticText15 = new wxStaticText( itemDialog1, wxID_STATIC, _("Colour:"), wxDefaultPosition, wxDefaultSize, 0 );

         itemFlexGridSizer4->Add(itemStaticText15, 0, wxALIGN_RIGHT|wxALIGN_TOP|wxALL, 5);

568

         m_colourCtrl = new wxFontColourSwatchCtrl( itemDialog1, wxID_FONTDIALOG_COLOUR, wxDefaultPosition, wxSize(-1, 30), wxSUNKEN_BORDER|wxTAB_TRAVERSAL );

         m_colourCtrl->SetHelpText(_("Click to change the font colour."));

571 if (ShowToolTips())

             m_colourCtrl->SetToolTip(_("Click to change the font colour."));

         itemFlexGridSizer4->Add(m_colourCtrl, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

574 }

575

     wxStaticText* itemStaticText17 = new wxStaticText( itemDialog1, wxID_STATIC, _("Preview:"), wxDefaultPosition, wxDefaultSize, 0 );

     itemFlexGridSizer4->Add(itemStaticText17, 0, wxALIGN_RIGHT|wxALIGN_TOP|wxALL, 5);

578

     m_previewCtrl = new wxFontPreviewCtrl( itemDialog1, wxID_FONTDIALOG_PREVIEW, wxDefaultPosition, wxSize(-1, 70), wxSUNKEN_BORDER|wxTAB_TRAVERSAL );

     m_previewCtrl->SetHelpText(_("Shows a preview of the font."));

581 if (ShowToolTips())

         m_previewCtrl->SetToolTip(_("Shows a preview of the font."));

     itemFlexGridSizer4->Add(m_previewCtrl, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5);

584

     wxBoxSizer* itemBoxSizer19 = new wxBoxSizer(wxHORIZONTAL);

     itemBoxSizer3->Add(itemBoxSizer19, 0, wxALIGN_RIGHT|wxALL, 5);

587

     wxButton* itemButton20 = new wxButton( itemDialog1, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

     itemButton20->SetHelpText(_("Click to cancel changes to the font."));

590 if (ShowToolTips())

         itemButton20->SetToolTip(_("Click to cancel changes to the font."));

     itemBoxSizer19->Add(itemButton20, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

593

     wxButton* itemButton21 = new wxButton( itemDialog1, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );

595 itemButton21->SetDefault();

     itemButton21->SetHelpText(_("Click to confirm changes to the font."));

597 if (ShowToolTips())

         itemButton21->SetToolTip(_("Click to confirm changes to the font."));

     itemBoxSizer19->Add(itemButton21, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

600

601 wxFontEnumerator enumerator;

602 enumerator.EnumerateFacenames();

603 wxArrayString facenames = enumerator.GetFacenames();

     if (!facenames.empty())

605 {

         facenames.Add(_("<Any>"));

         facenames.Add(_("<Any Roman>"));

         facenames.Add(_("<Any Decorative>"));

         facenames.Add(_("<Any Modern>"));

         facenames.Add(_("<Any Script>"));

         facenames.Add(_("<Any Swiss>"));

         facenames.Add(_("<Any Teletype>"));

613 facenames.Sort();

614 m_facenameCtrl->Append(facenames);

615 }

616

617 InitializeControls();

618 m_previewCtrl->SetFont(m_dialogFont);

     if (m_fontData.GetColour().IsOk())

620 {

         m_previewCtrl->SetForegroundColour(m_fontData.GetColour());

622 }

623 m_previewCtrl->Refresh();

624 }

625

626 /*!

627 * wxEVT_SPINCTRL event handler for wxID_FONTDIALOG_FONTSIZE

628 */

629

 void wxFontDialog::OnFontdialogFontsizeUpdated( wxSpinEvent& WXUNUSED(event) )

631 {

632 ChangeFont();

633 }

634

635 /*!

636 * wxEVT_TEXT event handler for wxID_FONTDIALOG_FONTSIZE

637 */

638

 void wxFontDialog::OnFontdialogFontsizeTextUpdated( wxCommandEvent& WXUNUSED(event) )

640 {

641 ChangeFont();

642 }

643

644 /*!

645 * wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_BOLD

646 */

647

 void wxFontDialog::OnFontdialogBoldClick( wxCommandEvent& WXUNUSED(event) )

649 {

650 ChangeFont();

651 }

652

653 /*!

654 * wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_ITALIC

655 */

656

 void wxFontDialog::OnFontdialogItalicClick( wxCommandEvent& WXUNUSED(event) )

658 {

659 ChangeFont();

660 }

661

662 /*!

663 * wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_UNDERLINED

664 */

665

 void wxFontDialog::OnFontdialogUnderlinedClick( wxCommandEvent& WXUNUSED(event) )

667 {

668 ChangeFont();

669 }

670

671 /*!

672 * wxEVT_BUTTON event handler for wxID_OK

673 */

674

 void wxFontDialog::OnOkClick( wxCommandEvent& event )

676 {

677 event.Skip();

678 }

679

680

681 /*!

682 * wxEVT_LISTBOX event handler for wxID_FONTDIALOG_FACENAME

683 */

684

 void wxFontDialog::OnFontdialogFacenameSelected( wxCommandEvent& WXUNUSED(event) )

686 {

687 ChangeFont();

688 }

689

 void wxFontDialog::OnColourChanged(wxCommandEvent & WXUNUSED(event))

691 {

     m_fontData.SetColour(m_colourCtrl->GetColour());

     m_previewCtrl->SetForegroundColour(m_colourCtrl->GetColour());

694 m_previewCtrl->Refresh();

695 }

696

697 /*!

698 * Should we show tooltips?

699 */

700

 bool wxFontDialog::ShowToolTips()

702 {

703 return true;

704 }

705

 void wxFontDialog::InitializeFont()

707 {

708 int fontFamily = wxSWISS;

709 int fontWeight = wxNORMAL;

710 int fontStyle = wxNORMAL;

711 int fontSize = 12;

712 bool fontUnderline = false;

713 wxString fontName;

714

     if (m_fontData.m_initialFont.IsOk())

716 {

         fontFamily = m_fontData.m_initialFont.GetFamily();

         fontWeight = m_fontData.m_initialFont.GetWeight();

         fontStyle = m_fontData.m_initialFont.GetStyle();

         fontSize = m_fontData.m_initialFont.GetPointSize();

         fontUnderline = m_fontData.m_initialFont.GetUnderlined();

         fontName = m_fontData.m_initialFont.GetFaceName();

723 }

724

     m_dialogFont = wxFont(fontSize, fontFamily, fontStyle,

726 fontWeight, fontUnderline, fontName);

727

728 if (m_previewCtrl)

729 m_previewCtrl->SetFont(m_dialogFont);

730

731 m_fontData.SetChosenFont(m_dialogFont);

732 }

733

734 /// Set controls according to current font

 void wxFontDialog::InitializeControls()

736 {

737 m_suppressUpdates = true;

738

739 if (m_underlinedCtrl)

         m_underlinedCtrl->SetValue(m_dialogFont.GetUnderlined());

741

     m_boldCtrl->SetValue(m_dialogFont.GetWeight() == wxBOLD);

     m_italicCtrl->SetValue(m_dialogFont.GetStyle() == wxITALIC);

     m_sizeCtrl->SetValue(m_dialogFont.GetPointSize());

745

746 wxString facename = m_dialogFont.GetFaceName();

     if (facename.empty() || m_facenameCtrl->FindString(facename) == wxNOT_FOUND)

748 {

         facename = FontFamilyIntToString(m_dialogFont.GetFamily());

750 }

751 m_facenameCtrl->SetStringSelection(facename);

752

     if (m_colourCtrl && m_fontData.GetColour().IsOk())

754 {

         m_colourCtrl->SetColour(m_fontData.GetColour());

756 m_colourCtrl->Refresh();

757 }

758

759 m_suppressUpdates = false;

760 }

761

762 /// Respond to font change

 void wxFontDialog::ChangeFont()

764 {

765 if (m_suppressUpdates)

766 return;

767

     bool underlined = m_underlinedCtrl ? m_underlinedCtrl->GetValue() : false;

     bool italic = m_italicCtrl->GetValue();

     bool bold = m_boldCtrl->GetValue();

     int size = m_sizeCtrl->GetValue();

772 wxString facename = m_facenameCtrl->GetStringSelection();

773

     int family = FontFamilyStringToInt(facename);

     if (family == -1)

776 family = wxDEFAULT;

777 else

778 facename = wxEmptyString;

779

     m_dialogFont = wxFont(size, family, italic ? wxITALIC : wxNORMAL, bold ? wxBOLD : wxNORMAL,

781 underlined, facename);

782

783 m_fontData.SetChosenFont(m_dialogFont);

784

785 m_previewCtrl->SetFont(m_dialogFont);

786 m_previewCtrl->Refresh();

787 }

788

 void wxFontDialog::SetData(const wxFontData& fontdata)

790 {

791 m_fontData = fontdata;

792 }

793

 bool wxFontDialog::IsShown() const

795 {

796 return false;

797 }

798

 int wxFontDialog::ShowModal()

800 {

     return wxDialog::ShowModal();

802 }

803

 void wxFontDialog::OnPanelClose()

805 {

806 }

807

 const wxChar *FontFamilyIntToString(int family)

809 {

810 switch (family)

811 {

812 case wxROMAN:

             return _("<Any Roman>");

814 case wxDECORATIVE:

             return _("<Any Decorative>");

816 case wxMODERN:

             return _("<Any Modern>");

818 case wxSCRIPT:

             return _("<Any Script>");

820 case wxTELETYPE:

             return _("<Any Teletype>");

822 case wxSWISS:

823 default:

             return _("<Any Swiss>");

825 }

826 }

827

 int FontFamilyStringToInt(const wxChar *family)

829 {

830 if (!family)

831 return wxSWISS;

832

     if (wxStrcmp(family, _("<Any Roman>")) == 0)

834 return wxROMAN;

     else if (wxStrcmp(family, _("<Any Decorative>")) == 0)

836 return wxDECORATIVE;

     else if (wxStrcmp(family, _("<Any Modern>")) == 0)

838 return wxMODERN;

     else if (wxStrcmp(family, _("<Any Script>")) == 0)

840 return wxSCRIPT;

     else if (wxStrcmp(family, _("<Any Teletype>")) == 0)

842 return wxTELETYPE;

     else if (wxStrcmp(family, _("<Any Swiss>")) == 0)

844 return wxSWISS;

845 else return -1;

846 }

847

848 #endif // !USE_NATIVE_FONT_DIALOG_FOR_MACOSX

849

850 #endif // wxOSX_USE_EXPERIMENTAL_FONTDIALOG

851

852 #endif // wxUSE_FONTDLG