src/generic/fontdlgg.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/generic/fontdlgg.cpp
// Purpose:     Generic font dialog
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#if wxUSE_FONTDLG && (!defined(__WXGTK__) || defined(__WXGPE__) || defined(__WXUNIVERSAL__))

#ifndef WX_PRECOMP
    #include <stdio.h>
    #include "wx/utils.h"
    #include "wx/dialog.h"
    #include "wx/listbox.h"
    #include "wx/button.h"
    #include "wx/stattext.h"
    #include "wx/layout.h"
    #include "wx/dcclient.h"
    #include "wx/choice.h"
    #include "wx/checkbox.h"
    #include "wx/intl.h"
#endif

#include <string.h>
#include <stdlib.h>

#include "wx/cmndata.h"
#include "wx/sizer.h"
#include "wx/fontdlg.h"
#include "wx/generic/fontdlgg.h"
#include "wx/settings.h"

#if USE_SPINCTRL_FOR_POINT_SIZE
#include "wx/spinctrl.h"
#endif

//-----------------------------------------------------------------------------
// helper class - wxFontPreviewer
//-----------------------------------------------------------------------------

class WXDLLEXPORT wxFontPreviewer : public wxWindow
{
public:
    wxFontPreviewer(wxWindow *parent, const wxSize& sz = wxDefaultSize) : wxWindow(parent, wxID_ANY, wxDefaultPosition, sz)
    {
    }

private:
    void OnPaint(wxPaintEvent& event);
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(wxFontPreviewer, wxWindow)
    EVT_PAINT(wxFontPreviewer::OnPaint)
END_EVENT_TABLE()

void wxFontPreviewer::OnPaint(wxPaintEvent& WXUNUSED(event))
{
    wxPaintDC dc(this);

    wxSize size = GetSize();
    wxFont font = GetFont();

    dc.SetPen(*wxBLACK_PEN);
    dc.SetBrush(*wxWHITE_BRUSH);
    dc.DrawRectangle(0, 0, size.x, size.y);

    if ( font.Ok() )
    {
        dc.SetFont(font);
        // 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);
        dc.DestroyClippingRegion();
    }
}

//-----------------------------------------------------------------------------
// wxGenericFontDialog
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxGenericFontDialog, wxDialog)

BEGIN_EVENT_TABLE(wxGenericFontDialog, wxDialog)
    EVT_CHECKBOX(wxID_FONT_UNDERLINE, wxGenericFontDialog::OnChangeFont)
    EVT_CHOICE(wxID_FONT_STYLE, wxGenericFontDialog::OnChangeFont)
    EVT_CHOICE(wxID_FONT_WEIGHT, wxGenericFontDialog::OnChangeFont)
    EVT_CHOICE(wxID_FONT_FAMILY, wxGenericFontDialog::OnChangeFont)
    EVT_CHOICE(wxID_FONT_COLOUR, wxGenericFontDialog::OnChangeFont)
#if USE_SPINCTRL_FOR_POINT_SIZE
    EVT_SPINCTRL(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeSize)
    EVT_TEXT(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
#else
    EVT_CHOICE(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
#endif
    EVT_CLOSE(wxGenericFontDialog::OnCloseWindow)
END_EVENT_TABLE()


#define NUM_COLS 48
static wxString wxColourDialogNames[NUM_COLS]={wxT("ORANGE"),
                    wxT("GOLDENROD"),
                    wxT("WHEAT"),
                    wxT("SPRING GREEN"),
                    wxT("SKY BLUE"),
                    wxT("SLATE BLUE"),
                    wxT("MEDIUM VIOLET RED"),
                    wxT("PURPLE"),

                    wxT("RED"),
                    wxT("YELLOW"),
                    wxT("MEDIUM SPRING GREEN"),
                    wxT("PALE GREEN"),
                    wxT("CYAN"),
                    wxT("LIGHT STEEL BLUE"),
                    wxT("ORCHID"),
                    wxT("LIGHT MAGENTA"),

                    wxT("BROWN"),
                    wxT("YELLOW"),
                    wxT("GREEN"),
                    wxT("CADET BLUE"),
                    wxT("MEDIUM BLUE"),
                    wxT("MAGENTA"),
                    wxT("MAROON"),
                    wxT("ORANGE RED"),

                    wxT("FIREBRICK"),
                    wxT("CORAL"),
                    wxT("FOREST GREEN"),
                    wxT("AQUARAMINE"),
                    wxT("BLUE"),
                    wxT("NAVY"),
                    wxT("THISTLE"),
                    wxT("MEDIUM VIOLET RED"),

                    wxT("INDIAN RED"),
                    wxT("GOLD"),
                    wxT("MEDIUM SEA GREEN"),
                    wxT("MEDIUM BLUE"),
                    wxT("MIDNIGHT BLUE"),
                    wxT("GREY"),
                    wxT("PURPLE"),
                    wxT("KHAKI"),

                    wxT("BLACK"),
                    wxT("MEDIUM FOREST GREEN"),
                    wxT("KHAKI"),
                    wxT("DARK GREY"),
                    wxT("SEA GREEN"),
                    wxT("LIGHT GREY"),
                    wxT("MEDIUM SLATE BLUE"),
                    wxT("WHITE")
                    };

/*
 * Generic wxFontDialog
 */

void wxGenericFontDialog::Init()
{
    m_useEvents = false;
    m_previewer = NULL;
    Create( m_parent ) ;
}

wxGenericFontDialog::~wxGenericFontDialog()
{
}

void wxGenericFontDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
{
    EndModal(wxID_CANCEL);
}

bool wxGenericFontDialog::DoCreate(wxWindow *parent)
{
    if ( !wxDialog::Create( parent , wxID_ANY , _T("Choose Font") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE,
        _T("fontdialog") ) )
    {
        wxFAIL_MSG( wxT("wxFontDialog creation failed") );
        return false;
    }

    InitializeFont();
    CreateWidgets();

    // sets initial font in preview area
    DoChangeFont();

    return true;
}

int wxGenericFontDialog::ShowModal()
{
    int ret = wxDialog::ShowModal();

    if (ret != wxID_CANCEL)
    {
        m_fontData.m_chosenFont = m_dialogFont;
    }

    return ret;
}

// This should be application-settable
static bool ShowToolTips() { return false; }

void wxGenericFontDialog::CreateWidgets()
{
    wxString *families = new wxString[6],
             *styles = new wxString[3],
             *weights = new wxString[3];
    families[0] =  _("Roman");
    families[1] = _("Decorative");
    families[2] = _("Modern");
    families[3] = _("Script");
    families[4] = _("Swiss" );
    families[5] = _("Teletype" );
    styles[0] = _("Normal");
    styles[1] = _("Italic");
    styles[2] = _("Slant");
    weights[0] = _("Normal");
    weights[1] = _("Light");
    weights[2] = _("Bold");

#if !USE_SPINCTRL_FOR_POINT_SIZE
    wxString *pointSizes = new wxString[40];
    int i;
    for ( i = 0; i < 40; i++)
    {
        wxChar buf[5];
        wxSprintf(buf, wxT("%d"), i + 1);
        pointSizes[i] = buf;
    }
#endif

    // layout

    bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
    int noCols, noRows;
    if (is_pda)
    {
        noCols = 2; noRows = 3;
    }
    else
    {
        noCols = 3; noRows = 2;
    }

    wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
    this->SetSizer(itemBoxSizer2);
    this->SetAutoLayout(true);

    wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxVERTICAL);
    itemBoxSizer2->Add(itemBoxSizer3, 1, wxGROW|wxALL, 5);

    wxFlexGridSizer* itemGridSizer4 = new wxFlexGridSizer(noRows, noCols, 0, 0);
    itemBoxSizer3->Add(itemGridSizer4, 0, wxGROW, 5);

    wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxVERTICAL);
    itemGridSizer4->Add(itemBoxSizer5, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW, 5);
    wxStaticText* itemStaticText6 = new wxStaticText( this, wxID_STATIC, _("&Font family:"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer5->Add(itemStaticText6, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

    wxChoice* itemChoice7 = new wxChoice( this, wxID_FONT_FAMILY, wxDefaultPosition, wxDefaultSize, 5, families, 0 );
    itemChoice7->SetHelpText(_("The font family."));
    if (ShowToolTips())
        itemChoice7->SetToolTip(_("The font family."));
    itemBoxSizer5->Add(itemChoice7, 0, wxALIGN_LEFT|wxALL, 5);

    wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxVERTICAL);
    itemGridSizer4->Add(itemBoxSizer8, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW, 5);
    wxStaticText* itemStaticText9 = new wxStaticText( this, wxID_STATIC, _("&Style:"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer8->Add(itemStaticText9, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

    wxChoice* itemChoice10 = new wxChoice( this, wxID_FONT_STYLE, wxDefaultPosition, wxDefaultSize, 3, styles, 0 );
    itemChoice10->SetHelpText(_("The font style."));
    if (ShowToolTips())
        itemChoice10->SetToolTip(_("The font style."));
    itemBoxSizer8->Add(itemChoice10, 0, wxALIGN_LEFT|wxALL, 5);

    wxBoxSizer* itemBoxSizer11 = new wxBoxSizer(wxVERTICAL);
    itemGridSizer4->Add(itemBoxSizer11, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW, 5);
    wxStaticText* itemStaticText12 = new wxStaticText( this, wxID_STATIC, _("&Weight:"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer11->Add(itemStaticText12, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

    wxChoice* itemChoice13 = new wxChoice( this, wxID_FONT_WEIGHT, wxDefaultPosition, wxDefaultSize, 3, weights, 0 );
    itemChoice13->SetHelpText(_("The font weight."));
    if (ShowToolTips())
        itemChoice13->SetToolTip(_("The font weight."));
    itemBoxSizer11->Add(itemChoice13, 0, wxALIGN_LEFT|wxALL, 5);

    wxBoxSizer* itemBoxSizer14 = new wxBoxSizer(wxVERTICAL);
    itemGridSizer4->Add(itemBoxSizer14, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW, 5);
    if (m_fontData.GetEnableEffects())
    {
        wxStaticText* itemStaticText15 = new wxStaticText( this, wxID_STATIC, _("C&olour:"), wxDefaultPosition, wxDefaultSize, 0 );
        itemBoxSizer14->Add(itemStaticText15, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

        wxSize colourSize = wxDefaultSize;
        if (is_pda)
            colourSize.x = 100;

        wxChoice* itemChoice16 = new wxChoice( this, wxID_FONT_COLOUR, wxDefaultPosition, colourSize, NUM_COLS, wxColourDialogNames, 0 );
        itemChoice16->SetHelpText(_("The font colour."));
        if (ShowToolTips())
            itemChoice16->SetToolTip(_("The font colour."));
        itemBoxSizer14->Add(itemChoice16, 0, wxALIGN_LEFT|wxALL, 5);
    }

    wxBoxSizer* itemBoxSizer17 = new wxBoxSizer(wxVERTICAL);
    itemGridSizer4->Add(itemBoxSizer17, 0, wxALIGN_CENTER_HORIZONTAL|wxGROW, 5);
    wxStaticText* itemStaticText18 = new wxStaticText( this, wxID_STATIC, _("&Point size:"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer17->Add(itemStaticText18, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

#if USE_SPINCTRL_FOR_POINT_SIZE
    wxSpinCtrl* spinCtrl = new wxSpinCtrl(this, wxID_FONT_SIZE, wxT("12"), wxDefaultPosition, wxSize(80, wxDefaultCoord), wxSP_ARROW_KEYS, 1, 500, 12);
    spinCtrl->SetHelpText(_("The font point size."));
    if (ShowToolTips())
        spinCtrl->SetToolTip(_("The font point size."));

    itemBoxSizer17->Add(spinCtrl, 0, wxALIGN_LEFT|wxALL, 5);
#else
    wxChoice* itemChoice19 = new wxChoice( this, wxID_FONT_SIZE, wxDefaultPosition, wxDefaultSize, 40, pointSizes, 0 );
    itemChoice19->SetHelpText(_("The font point size."));
    if (ShowToolTips())
        itemChoice19->SetToolTip(_("The font point size."));
    itemBoxSizer17->Add(itemChoice19, 0, wxALIGN_LEFT|wxALL, 5);
#endif

    if (m_fontData.GetEnableEffects())
    {
        wxBoxSizer* itemBoxSizer20 = new wxBoxSizer(wxVERTICAL);
        itemGridSizer4->Add(itemBoxSizer20, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL, 5);
        wxCheckBox* itemCheckBox21 = new wxCheckBox( this, wxID_FONT_UNDERLINE, _("&Underline"), wxDefaultPosition, wxDefaultSize, 0 );
        itemCheckBox21->SetValue(false);
        itemCheckBox21->SetHelpText(_("Whether the font is underlined."));
        if (ShowToolTips())
            itemCheckBox21->SetToolTip(_("Whether the font is underlined."));
        itemBoxSizer20->Add(itemCheckBox21, 0, wxALIGN_LEFT|wxALL, 5);
    }

    if (!is_pda)
        itemBoxSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxStaticText* itemStaticText23 = new wxStaticText( this, wxID_STATIC, _("Preview:"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer3->Add(itemStaticText23, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);

    wxFontPreviewer* itemWindow24 = new wxFontPreviewer( this );
    m_previewer = itemWindow24;
    itemWindow24->SetHelpText(_("Shows the font preview."));
    if (ShowToolTips())
        itemWindow24->SetToolTip(_("Shows the font preview."));
    itemBoxSizer3->Add(itemWindow24, 1, wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer25 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer3->Add(itemBoxSizer25, 0, wxGROW, 5);
    itemBoxSizer25->Add(5, 5, 1, wxGROW|wxALL, 5);

#ifdef __WXMAC__
    wxButton* itemButton28 = new wxButton( this, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        itemButton28->SetToolTip(_("Click to cancel the font selection."));
    itemBoxSizer25->Add(itemButton28, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton27 = new wxButton( this, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton27->SetDefault();
    itemButton27->SetHelpText(_("Click to confirm the font selection."));
    if (ShowToolTips())
        itemButton27->SetToolTip(_("Click to confirm the font selection."));
    itemBoxSizer25->Add(itemButton27, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
#else
    wxButton* itemButton27 = new wxButton( this, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
    itemButton27->SetDefault();
    itemButton27->SetHelpText(_("Click to confirm the font selection."));
    if (ShowToolTips())
        itemButton27->SetToolTip(_("Click to confirm the font selection."));
    itemBoxSizer25->Add(itemButton27, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton28 = new wxButton( this, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        itemButton28->SetToolTip(_("Click to cancel the font selection."));
    itemBoxSizer25->Add(itemButton28, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
#endif

    m_familyChoice = (wxChoice*) FindWindow(wxID_FONT_FAMILY);
    m_styleChoice = (wxChoice*) FindWindow(wxID_FONT_STYLE);
    m_weightChoice = (wxChoice*) FindWindow(wxID_FONT_WEIGHT);
    m_colourChoice = (wxChoice*) FindWindow(wxID_FONT_COLOUR);
    m_underLineCheckBox = (wxCheckBox*) FindWindow(wxID_FONT_UNDERLINE);

    m_familyChoice->SetStringSelection( wxFontFamilyIntToString(m_dialogFont.GetFamily()) );
    m_styleChoice->SetStringSelection(wxFontStyleIntToString(m_dialogFont.GetStyle()));
    m_weightChoice->SetStringSelection(wxFontWeightIntToString(m_dialogFont.GetWeight()));

    if (m_colourChoice)
    {
        wxString name(wxTheColourDatabase->FindName(m_fontData.GetColour()));
        if (name.length())
            m_colourChoice->SetStringSelection(name);
        else
            m_colourChoice->SetStringSelection(wxT("BLACK"));
    }

    if (m_underLineCheckBox)
    {
        m_underLineCheckBox->SetValue(m_dialogFont.GetUnderlined());
    }

#if USE_SPINCTRL_FOR_POINT_SIZE
    spinCtrl->SetValue(m_dialogFont.GetPointSize());
#else
    m_pointSizeChoice = (wxChoice*) FindWindow(wxID_FONT_SIZE);
    m_pointSizeChoice->SetSelection(m_dialogFont.GetPointSize()-1);
#endif

#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
    GetSizer()->SetItemMinSize(m_previewer, is_pda ? 100 : 430, is_pda ? 40 : 100);
    GetSizer()->SetSizeHints(this);
    GetSizer()->Fit(this);

    Centre(wxBOTH);
#endif

    delete[] families;
    delete[] styles;
    delete[] weights;
#if !USE_SPINCTRL_FOR_POINT_SIZE
    delete[] pointSizes;
#endif

    // Don't block events any more
    m_useEvents = true;

}

void wxGenericFontDialog::InitializeFont()
{
    int fontFamily = wxSWISS;
    int fontWeight = wxNORMAL;
    int fontStyle = wxNORMAL;
    int fontSize = 12;
    bool fontUnderline = false;

    if (m_fontData.m_initialFont.Ok())
    {
        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();
    }

    m_dialogFont = wxFont(fontSize, fontFamily, fontStyle,
                          fontWeight, fontUnderline);

    if (m_previewer)
        m_previewer->SetFont(m_dialogFont);
}

void wxGenericFontDialog::OnChangeFont(wxCommandEvent& WXUNUSED(event))
{
    DoChangeFont();
}

void wxGenericFontDialog::DoChangeFont()
{
    if (!m_useEvents) return;

    int fontFamily = wxFontFamilyStringToInt(WXSTRINGCAST m_familyChoice->GetStringSelection());
    int fontWeight = wxFontWeightStringToInt(WXSTRINGCAST m_weightChoice->GetStringSelection());
    int fontStyle = wxFontStyleStringToInt(WXSTRINGCAST m_styleChoice->GetStringSelection());
#if USE_SPINCTRL_FOR_POINT_SIZE
    wxSpinCtrl* fontSizeCtrl = wxDynamicCast(FindWindow(wxID_FONT_SIZE), wxSpinCtrl);
    int fontSize = fontSizeCtrl->GetValue();
#else
    int fontSize = wxAtoi(m_pointSizeChoice->GetStringSelection());
#endif

    // Start with previous underline setting, we want to retain it even if we can't edit it
    // m_dialogFont is always initialized because of the call to InitializeFont
    int fontUnderline = m_dialogFont.GetUnderlined();

    if (m_underLineCheckBox)
    {
        fontUnderline = m_underLineCheckBox->GetValue();
    }

    m_dialogFont = wxFont(fontSize, fontFamily, fontStyle, fontWeight, (fontUnderline != 0));
    m_previewer->SetFont(m_dialogFont);

    if ( m_colourChoice )
    {
        if ( !m_colourChoice->GetStringSelection().empty() )
        {
            wxColour col = wxTheColourDatabase->Find(m_colourChoice->GetStringSelection());
            if (col.Ok())
            {
                m_fontData.m_fontColour = col;
            }
        }
    }
    // Update color here so that we can also use the color originally passed in
    // (EnableEffects may be false)
    if (m_fontData.m_fontColour.Ok())
        m_previewer->SetForegroundColour(m_fontData.m_fontColour);

    m_previewer->Refresh();
}

#if USE_SPINCTRL_FOR_POINT_SIZE
void wxGenericFontDialog::OnChangeSize(wxSpinEvent& WXUNUSED(event))
{
    DoChangeFont();
}
#endif

const wxChar *wxFontWeightIntToString(int weight)
{
    switch (weight)
    {
        case wxLIGHT:
            return wxT("Light");
        case wxBOLD:
            return wxT("Bold");
        case wxNORMAL:
        default:
            return wxT("Normal");
    }
}

const wxChar *wxFontStyleIntToString(int style)
{
    switch (style)
    {
        case wxITALIC:
            return wxT("Italic");
        case wxSLANT:
            return wxT("Slant");
        case wxNORMAL:
            default:
            return wxT("Normal");
    }
}

const wxChar *wxFontFamilyIntToString(int family)
{
    switch (family)
    {
        case wxROMAN:
            return wxT("Roman");
        case wxDECORATIVE:
            return wxT("Decorative");
        case wxMODERN:
            return wxT("Modern");
        case wxSCRIPT:
            return wxT("Script");
        case wxTELETYPE:
            return wxT("Teletype");
        case wxSWISS:
        default:
            return wxT("Swiss");
    }
}

int wxFontFamilyStringToInt(wxChar *family)
{
    if (!family)
        return wxSWISS;

    if (wxStrcmp(family, wxT("Roman")) == 0)
        return wxROMAN;
    else if (wxStrcmp(family, wxT("Decorative")) == 0)
        return wxDECORATIVE;
    else if (wxStrcmp(family, wxT("Modern")) == 0)
        return wxMODERN;
    else if (wxStrcmp(family, wxT("Script")) == 0)
        return wxSCRIPT;
    else if (wxStrcmp(family, wxT("Teletype")) == 0)
        return wxTELETYPE;
    else return wxSWISS;
}

int wxFontStyleStringToInt(wxChar *style)
{
    if (!style)
        return wxNORMAL;
    if (wxStrcmp(style, wxT("Italic")) == 0)
        return wxITALIC;
    else if (wxStrcmp(style, wxT("Slant")) == 0)
        return wxSLANT;
    else
        return wxNORMAL;
}

int wxFontWeightStringToInt(wxChar *weight)
{
    if (!weight)
        return wxNORMAL;
    if (wxStrcmp(weight, wxT("Bold")) == 0)
        return wxBOLD;
    else if (wxStrcmp(weight, wxT("Light")) == 0)
        return wxLIGHT;
    else
        return wxNORMAL;
}

#endif
    // wxUSE_FONTDLG
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/generic/fontdlgg.cpp
	3	// Purpose: Generic font dialog
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#if wxUSE_FONTDLG && (!defined(__WXGTK__) \|\| defined(__WXGPE__) \|\| defined(__WXUNIVERSAL__))
	20
	21	#ifndef WX_PRECOMP
	22	#include <stdio.h>
	23	#include "wx/utils.h"
	24	#include "wx/dialog.h"
	25	#include "wx/listbox.h"
	26	#include "wx/button.h"
	27	#include "wx/stattext.h"
	28	#include "wx/layout.h"
	29	#include "wx/dcclient.h"
	30	#include "wx/choice.h"
	31	#include "wx/checkbox.h"
	32	#include "wx/intl.h"
	33	#endif
	34
	35	#include <string.h>
	36	#include <stdlib.h>
	37
	38	#include "wx/cmndata.h"
	39	#include "wx/sizer.h"
	40	#include "wx/fontdlg.h"
	41	#include "wx/generic/fontdlgg.h"
	42	#include "wx/settings.h"
	43
	44	#if USE_SPINCTRL_FOR_POINT_SIZE
	45	#include "wx/spinctrl.h"
	46	#endif
	47
	48	//-----------------------------------------------------------------------------
	49	// helper class - wxFontPreviewer
	50	//-----------------------------------------------------------------------------
	51
	52	class WXDLLEXPORT wxFontPreviewer : public wxWindow
	53	{
	54	public:
	55	wxFontPreviewer(wxWindow *parent, const wxSize& sz = wxDefaultSize) : wxWindow(parent, wxID_ANY, wxDefaultPosition, sz)
	56	{
	57	}
	58
	59	private:
	60	void OnPaint(wxPaintEvent& event);
	61	DECLARE_EVENT_TABLE()
	62	};
	63
	64	BEGIN_EVENT_TABLE(wxFontPreviewer, wxWindow)
	65	EVT_PAINT(wxFontPreviewer::OnPaint)
	66	END_EVENT_TABLE()
	67
	68	void wxFontPreviewer::OnPaint(wxPaintEvent& WXUNUSED(event))
	69	{
	70	wxPaintDC dc(this);
	71
	72	wxSize size = GetSize();
	73	wxFont font = GetFont();
	74
	75	dc.SetPen(*wxBLACK_PEN);
	76	dc.SetBrush(*wxWHITE_BRUSH);
	77	dc.DrawRectangle(0, 0, size.x, size.y);
	78
	79	if ( font.Ok() )
	80	{
	81	dc.SetFont(font);
	82	// Calculate vertical centre
	83	long w = 0, h = 0;
	84	dc.GetTextExtent( wxT("X"), &w, &h);
	85	dc.SetTextForeground(GetForegroundColour());
	86	dc.SetClippingRegion(2, 2, size.x-4, size.y-4);
	87	dc.DrawText(_("ABCDEFGabcdefg12345"),
	88	10, size.y/2 - h/2);
	89	dc.DestroyClippingRegion();
	90	}
	91	}
	92
	93	//-----------------------------------------------------------------------------
	94	// wxGenericFontDialog
	95	//-----------------------------------------------------------------------------
	96
	97	IMPLEMENT_DYNAMIC_CLASS(wxGenericFontDialog, wxDialog)
	98
	99	BEGIN_EVENT_TABLE(wxGenericFontDialog, wxDialog)
	100	EVT_CHECKBOX(wxID_FONT_UNDERLINE, wxGenericFontDialog::OnChangeFont)
	101	EVT_CHOICE(wxID_FONT_STYLE, wxGenericFontDialog::OnChangeFont)
	102	EVT_CHOICE(wxID_FONT_WEIGHT, wxGenericFontDialog::OnChangeFont)
	103	EVT_CHOICE(wxID_FONT_FAMILY, wxGenericFontDialog::OnChangeFont)
	104	EVT_CHOICE(wxID_FONT_COLOUR, wxGenericFontDialog::OnChangeFont)
	105	#if USE_SPINCTRL_FOR_POINT_SIZE
	106	EVT_SPINCTRL(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeSize)
	107	EVT_TEXT(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
	108	#else
	109	EVT_CHOICE(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
	110	#endif
	111	EVT_CLOSE(wxGenericFontDialog::OnCloseWindow)
	112	END_EVENT_TABLE()
	113
	114
	115	#define NUM_COLS 48
	116	static wxString wxColourDialogNames[NUM_COLS]={wxT("ORANGE"),
	117	wxT("GOLDENROD"),
	118	wxT("WHEAT"),
	119	wxT("SPRING GREEN"),
	120	wxT("SKY BLUE"),
	121	wxT("SLATE BLUE"),
	122	wxT("MEDIUM VIOLET RED"),
	123	wxT("PURPLE"),
	124
	125	wxT("RED"),
	126	wxT("YELLOW"),
	127	wxT("MEDIUM SPRING GREEN"),
	128	wxT("PALE GREEN"),
	129	wxT("CYAN"),
	130	wxT("LIGHT STEEL BLUE"),
	131	wxT("ORCHID"),
	132	wxT("LIGHT MAGENTA"),
	133
	134	wxT("BROWN"),
	135	wxT("YELLOW"),
	136	wxT("GREEN"),
	137	wxT("CADET BLUE"),
	138	wxT("MEDIUM BLUE"),
	139	wxT("MAGENTA"),
	140	wxT("MAROON"),
	141	wxT("ORANGE RED"),
	142
	143	wxT("FIREBRICK"),
	144	wxT("CORAL"),
	145	wxT("FOREST GREEN"),
	146	wxT("AQUARAMINE"),
	147	wxT("BLUE"),
	148	wxT("NAVY"),
	149	wxT("THISTLE"),
	150	wxT("MEDIUM VIOLET RED"),
	151
	152	wxT("INDIAN RED"),
	153	wxT("GOLD"),
	154	wxT("MEDIUM SEA GREEN"),
	155	wxT("MEDIUM BLUE"),
	156	wxT("MIDNIGHT BLUE"),
	157	wxT("GREY"),
	158	wxT("PURPLE"),
	159	wxT("KHAKI"),
	160
	161	wxT("BLACK"),
	162	wxT("MEDIUM FOREST GREEN"),
	163	wxT("KHAKI"),
	164	wxT("DARK GREY"),
	165	wxT("SEA GREEN"),
	166	wxT("LIGHT GREY"),
	167	wxT("MEDIUM SLATE BLUE"),
	168	wxT("WHITE")
	169	};
	170
	171	/*
	172	* Generic wxFontDialog
	173	*/
	174
	175	void wxGenericFontDialog::Init()
	176	{
	177	m_useEvents = false;
	178	m_previewer = NULL;
	179	Create( m_parent ) ;
	180	}
	181
	182	wxGenericFontDialog::~wxGenericFontDialog()
	183	{
	184	}
	185
	186	void wxGenericFontDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
	187	{
	188	EndModal(wxID_CANCEL);
	189	}
	190
	191	bool wxGenericFontDialog::DoCreate(wxWindow *parent)
	192	{
	193	if ( !wxDialog::Create( parent , wxID_ANY , _T("Choose Font") , wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE,
	194	_T("fontdialog") ) )
	195	{
	196	wxFAIL_MSG( wxT("wxFontDialog creation failed") );
	197	return false;
	198	}
	199
	200	InitializeFont();
	201	CreateWidgets();
	202
	203	// sets initial font in preview area
	204	DoChangeFont();
	205
	206	return true;
	207	}
	208
	209	int wxGenericFontDialog::ShowModal()
	210	{
	211	int ret = wxDialog::ShowModal();
	212
	213	if (ret != wxID_CANCEL)
	214	{
	215	m_fontData.m_chosenFont = m_dialogFont;
	216	}
	217
	218	return ret;
	219	}
	220
	221	// This should be application-settable
	222	static bool ShowToolTips() { return false; }
	223
	224	void wxGenericFontDialog::CreateWidgets()
	225	{
	226	wxString *families = new wxString[6],
	227	*styles = new wxString[3],
	228	*weights = new wxString[3];
	229	families[0] = _("Roman");
	230	families[1] = _("Decorative");
	231	families[2] = _("Modern");
	232	families[3] = _("Script");
	233	families[4] = _("Swiss" );
	234	families[5] = _("Teletype" );
	235	styles[0] = _("Normal");
	236	styles[1] = _("Italic");
	237	styles[2] = _("Slant");
	238	weights[0] = _("Normal");
	239	weights[1] = _("Light");
	240	weights[2] = _("Bold");
	241
	242	#if !USE_SPINCTRL_FOR_POINT_SIZE
	243	wxString *pointSizes = new wxString[40];
	244	int i;
	245	for ( i = 0; i < 40; i++)
	246	{
	247	wxChar buf[5];
	248	wxSprintf(buf, wxT("%d"), i + 1);
	249	pointSizes[i] = buf;
	250	}
	251	#endif
	252
	253	// layout
	254
	255	bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
	256	int noCols, noRows;
	257	if (is_pda)
	258	{
	259	noCols = 2; noRows = 3;
	260	}
	261	else
	262	{
	263	noCols = 3; noRows = 2;
	264	}
	265
	266	wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
	267	this->SetSizer(itemBoxSizer2);
	268	this->SetAutoLayout(true);
	269
	270	wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxVERTICAL);
	271	itemBoxSizer2->Add(itemBoxSizer3, 1, wxGROW\|wxALL, 5);
	272
	273	wxFlexGridSizer* itemGridSizer4 = new wxFlexGridSizer(noRows, noCols, 0, 0);
	274	itemBoxSizer3->Add(itemGridSizer4, 0, wxGROW, 5);
	275
	276	wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxVERTICAL);
	277	itemGridSizer4->Add(itemBoxSizer5, 0, wxALIGN_CENTER_HORIZONTAL\|wxGROW, 5);
	278	wxStaticText* itemStaticText6 = new wxStaticText( this, wxID_STATIC, _("&Font family:"), wxDefaultPosition, wxDefaultSize, 0 );
	279	itemBoxSizer5->Add(itemStaticText6, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	280
	281	wxChoice* itemChoice7 = new wxChoice( this, wxID_FONT_FAMILY, wxDefaultPosition, wxDefaultSize, 5, families, 0 );
	282	itemChoice7->SetHelpText(_("The font family."));
	283	if (ShowToolTips())
	284	itemChoice7->SetToolTip(_("The font family."));
	285	itemBoxSizer5->Add(itemChoice7, 0, wxALIGN_LEFT\|wxALL, 5);
	286
	287	wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxVERTICAL);
	288	itemGridSizer4->Add(itemBoxSizer8, 0, wxALIGN_CENTER_HORIZONTAL\|wxGROW, 5);
	289	wxStaticText* itemStaticText9 = new wxStaticText( this, wxID_STATIC, _("&Style:"), wxDefaultPosition, wxDefaultSize, 0 );
	290	itemBoxSizer8->Add(itemStaticText9, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	291
	292	wxChoice* itemChoice10 = new wxChoice( this, wxID_FONT_STYLE, wxDefaultPosition, wxDefaultSize, 3, styles, 0 );
	293	itemChoice10->SetHelpText(_("The font style."));
	294	if (ShowToolTips())
	295	itemChoice10->SetToolTip(_("The font style."));
	296	itemBoxSizer8->Add(itemChoice10, 0, wxALIGN_LEFT\|wxALL, 5);
	297
	298	wxBoxSizer* itemBoxSizer11 = new wxBoxSizer(wxVERTICAL);
	299	itemGridSizer4->Add(itemBoxSizer11, 0, wxALIGN_CENTER_HORIZONTAL\|wxGROW, 5);
	300	wxStaticText* itemStaticText12 = new wxStaticText( this, wxID_STATIC, _("&Weight:"), wxDefaultPosition, wxDefaultSize, 0 );
	301	itemBoxSizer11->Add(itemStaticText12, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	302
	303	wxChoice* itemChoice13 = new wxChoice( this, wxID_FONT_WEIGHT, wxDefaultPosition, wxDefaultSize, 3, weights, 0 );
	304	itemChoice13->SetHelpText(_("The font weight."));
	305	if (ShowToolTips())
	306	itemChoice13->SetToolTip(_("The font weight."));
	307	itemBoxSizer11->Add(itemChoice13, 0, wxALIGN_LEFT\|wxALL, 5);
	308
	309	wxBoxSizer* itemBoxSizer14 = new wxBoxSizer(wxVERTICAL);
	310	itemGridSizer4->Add(itemBoxSizer14, 0, wxALIGN_CENTER_HORIZONTAL\|wxGROW, 5);
	311	if (m_fontData.GetEnableEffects())
	312	{
	313	wxStaticText* itemStaticText15 = new wxStaticText( this, wxID_STATIC, _("C&olour:"), wxDefaultPosition, wxDefaultSize, 0 );
	314	itemBoxSizer14->Add(itemStaticText15, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	315
	316	wxSize colourSize = wxDefaultSize;
	317	if (is_pda)
	318	colourSize.x = 100;
	319
	320	wxChoice* itemChoice16 = new wxChoice( this, wxID_FONT_COLOUR, wxDefaultPosition, colourSize, NUM_COLS, wxColourDialogNames, 0 );
	321	itemChoice16->SetHelpText(_("The font colour."));
	322	if (ShowToolTips())
	323	itemChoice16->SetToolTip(_("The font colour."));
	324	itemBoxSizer14->Add(itemChoice16, 0, wxALIGN_LEFT\|wxALL, 5);
	325	}
	326
	327	wxBoxSizer* itemBoxSizer17 = new wxBoxSizer(wxVERTICAL);
	328	itemGridSizer4->Add(itemBoxSizer17, 0, wxALIGN_CENTER_HORIZONTAL\|wxGROW, 5);
	329	wxStaticText* itemStaticText18 = new wxStaticText( this, wxID_STATIC, _("&Point size:"), wxDefaultPosition, wxDefaultSize, 0 );
	330	itemBoxSizer17->Add(itemStaticText18, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	331
	332	#if USE_SPINCTRL_FOR_POINT_SIZE
	333	wxSpinCtrl* spinCtrl = new wxSpinCtrl(this, wxID_FONT_SIZE, wxT("12"), wxDefaultPosition, wxSize(80, wxDefaultCoord), wxSP_ARROW_KEYS, 1, 500, 12);
	334	spinCtrl->SetHelpText(_("The font point size."));
	335	if (ShowToolTips())
	336	spinCtrl->SetToolTip(_("The font point size."));
	337
	338	itemBoxSizer17->Add(spinCtrl, 0, wxALIGN_LEFT\|wxALL, 5);
	339	#else
	340	wxChoice* itemChoice19 = new wxChoice( this, wxID_FONT_SIZE, wxDefaultPosition, wxDefaultSize, 40, pointSizes, 0 );
	341	itemChoice19->SetHelpText(_("The font point size."));
	342	if (ShowToolTips())
	343	itemChoice19->SetToolTip(_("The font point size."));
	344	itemBoxSizer17->Add(itemChoice19, 0, wxALIGN_LEFT\|wxALL, 5);
	345	#endif
	346
	347	if (m_fontData.GetEnableEffects())
	348	{
	349	wxBoxSizer* itemBoxSizer20 = new wxBoxSizer(wxVERTICAL);
	350	itemGridSizer4->Add(itemBoxSizer20, 0, wxALIGN_LEFT\|wxALIGN_CENTER_VERTICAL, 5);
	351	wxCheckBox* itemCheckBox21 = new wxCheckBox( this, wxID_FONT_UNDERLINE, _("&Underline"), wxDefaultPosition, wxDefaultSize, 0 );
	352	itemCheckBox21->SetValue(false);
	353	itemCheckBox21->SetHelpText(_("Whether the font is underlined."));
	354	if (ShowToolTips())
	355	itemCheckBox21->SetToolTip(_("Whether the font is underlined."));
	356	itemBoxSizer20->Add(itemCheckBox21, 0, wxALIGN_LEFT\|wxALL, 5);
	357	}
	358
	359	if (!is_pda)
	360	itemBoxSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL\|wxALL, 5);
	361
	362	wxStaticText* itemStaticText23 = new wxStaticText( this, wxID_STATIC, _("Preview:"), wxDefaultPosition, wxDefaultSize, 0 );
	363	itemBoxSizer3->Add(itemStaticText23, 0, wxALIGN_LEFT\|wxLEFT\|wxRIGHT\|wxTOP\|wxADJUST_MINSIZE, 5);
	364
	365	wxFontPreviewer* itemWindow24 = new wxFontPreviewer( this );
	366	m_previewer = itemWindow24;
	367	itemWindow24->SetHelpText(_("Shows the font preview."));
	368	if (ShowToolTips())
	369	itemWindow24->SetToolTip(_("Shows the font preview."));
	370	itemBoxSizer3->Add(itemWindow24, 1, wxGROW\|wxALL, 5);
	371
	372	wxBoxSizer* itemBoxSizer25 = new wxBoxSizer(wxHORIZONTAL);
	373	itemBoxSizer3->Add(itemBoxSizer25, 0, wxGROW, 5);
	374	itemBoxSizer25->Add(5, 5, 1, wxGROW\|wxALL, 5);
	375
	376	#ifdef __WXMAC__
	377	wxButton* itemButton28 = new wxButton( this, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
	378	if (ShowToolTips())
	379	itemButton28->SetToolTip(_("Click to cancel the font selection."));
	380	itemBoxSizer25->Add(itemButton28, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5);
	381
	382	wxButton* itemButton27 = new wxButton( this, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
	383	itemButton27->SetDefault();
	384	itemButton27->SetHelpText(_("Click to confirm the font selection."));
	385	if (ShowToolTips())
	386	itemButton27->SetToolTip(_("Click to confirm the font selection."));
	387	itemBoxSizer25->Add(itemButton27, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5);
	388	#else
	389	wxButton* itemButton27 = new wxButton( this, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
	390	itemButton27->SetDefault();
	391	itemButton27->SetHelpText(_("Click to confirm the font selection."));
	392	if (ShowToolTips())
	393	itemButton27->SetToolTip(_("Click to confirm the font selection."));
	394	itemBoxSizer25->Add(itemButton27, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5);
	395
	396	wxButton* itemButton28 = new wxButton( this, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
	397	if (ShowToolTips())
	398	itemButton28->SetToolTip(_("Click to cancel the font selection."));
	399	itemBoxSizer25->Add(itemButton28, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5);
	400	#endif
	401
	402	m_familyChoice = (wxChoice*) FindWindow(wxID_FONT_FAMILY);
	403	m_styleChoice = (wxChoice*) FindWindow(wxID_FONT_STYLE);
	404	m_weightChoice = (wxChoice*) FindWindow(wxID_FONT_WEIGHT);
	405	m_colourChoice = (wxChoice*) FindWindow(wxID_FONT_COLOUR);
	406	m_underLineCheckBox = (wxCheckBox*) FindWindow(wxID_FONT_UNDERLINE);
	407
	408	m_familyChoice->SetStringSelection( wxFontFamilyIntToString(m_dialogFont.GetFamily()) );
	409	m_styleChoice->SetStringSelection(wxFontStyleIntToString(m_dialogFont.GetStyle()));
	410	m_weightChoice->SetStringSelection(wxFontWeightIntToString(m_dialogFont.GetWeight()));
	411
	412	if (m_colourChoice)
	413	{
	414	wxString name(wxTheColourDatabase->FindName(m_fontData.GetColour()));
	415	if (name.length())
	416	m_colourChoice->SetStringSelection(name);
	417	else
	418	m_colourChoice->SetStringSelection(wxT("BLACK"));
	419	}
	420
	421	if (m_underLineCheckBox)
	422	{
	423	m_underLineCheckBox->SetValue(m_dialogFont.GetUnderlined());
	424	}
	425
	426	#if USE_SPINCTRL_FOR_POINT_SIZE
	427	spinCtrl->SetValue(m_dialogFont.GetPointSize());
	428	#else
	429	m_pointSizeChoice = (wxChoice*) FindWindow(wxID_FONT_SIZE);
	430	m_pointSizeChoice->SetSelection(m_dialogFont.GetPointSize()-1);
	431	#endif
	432
	433	#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
	434	GetSizer()->SetItemMinSize(m_previewer, is_pda ? 100 : 430, is_pda ? 40 : 100);
	435	GetSizer()->SetSizeHints(this);
	436	GetSizer()->Fit(this);
	437
	438	Centre(wxBOTH);
	439	#endif
	440
	441	delete[] families;
	442	delete[] styles;
	443	delete[] weights;
	444	#if !USE_SPINCTRL_FOR_POINT_SIZE
	445	delete[] pointSizes;
	446	#endif
	447
	448	// Don't block events any more
	449	m_useEvents = true;
	450
	451	}
	452
	453	void wxGenericFontDialog::InitializeFont()
	454	{
	455	int fontFamily = wxSWISS;
	456	int fontWeight = wxNORMAL;
	457	int fontStyle = wxNORMAL;
	458	int fontSize = 12;
	459	bool fontUnderline = false;
	460
	461	if (m_fontData.m_initialFont.Ok())
	462	{
	463	fontFamily = m_fontData.m_initialFont.GetFamily();
	464	fontWeight = m_fontData.m_initialFont.GetWeight();
	465	fontStyle = m_fontData.m_initialFont.GetStyle();
	466	fontSize = m_fontData.m_initialFont.GetPointSize();
	467	fontUnderline = m_fontData.m_initialFont.GetUnderlined();
	468	}
	469
	470	m_dialogFont = wxFont(fontSize, fontFamily, fontStyle,
	471	fontWeight, fontUnderline);
	472
	473	if (m_previewer)
	474	m_previewer->SetFont(m_dialogFont);
	475	}
	476
	477	void wxGenericFontDialog::OnChangeFont(wxCommandEvent& WXUNUSED(event))
	478	{
	479	DoChangeFont();
	480	}
	481
	482	void wxGenericFontDialog::DoChangeFont()
	483	{
	484	if (!m_useEvents) return;
	485
	486	int fontFamily = wxFontFamilyStringToInt(WXSTRINGCAST m_familyChoice->GetStringSelection());
	487	int fontWeight = wxFontWeightStringToInt(WXSTRINGCAST m_weightChoice->GetStringSelection());
	488	int fontStyle = wxFontStyleStringToInt(WXSTRINGCAST m_styleChoice->GetStringSelection());
	489	#if USE_SPINCTRL_FOR_POINT_SIZE
	490	wxSpinCtrl* fontSizeCtrl = wxDynamicCast(FindWindow(wxID_FONT_SIZE), wxSpinCtrl);
	491	int fontSize = fontSizeCtrl->GetValue();
	492	#else
	493	int fontSize = wxAtoi(m_pointSizeChoice->GetStringSelection());
	494	#endif
	495
	496	// Start with previous underline setting, we want to retain it even if we can't edit it
	497	// m_dialogFont is always initialized because of the call to InitializeFont
	498	int fontUnderline = m_dialogFont.GetUnderlined();
	499
	500	if (m_underLineCheckBox)
	501	{
	502	fontUnderline = m_underLineCheckBox->GetValue();
	503	}
	504
	505	m_dialogFont = wxFont(fontSize, fontFamily, fontStyle, fontWeight, (fontUnderline != 0));
	506	m_previewer->SetFont(m_dialogFont);
	507
	508	if ( m_colourChoice )
	509	{
	510	if ( !m_colourChoice->GetStringSelection().empty() )
	511	{
	512	wxColour col = wxTheColourDatabase->Find(m_colourChoice->GetStringSelection());
	513	if (col.Ok())
	514	{
	515	m_fontData.m_fontColour = col;
	516	}
	517	}
	518	}
	519	// Update color here so that we can also use the color originally passed in
	520	// (EnableEffects may be false)
	521	if (m_fontData.m_fontColour.Ok())
	522	m_previewer->SetForegroundColour(m_fontData.m_fontColour);
	523
	524	m_previewer->Refresh();
	525	}
	526
	527	#if USE_SPINCTRL_FOR_POINT_SIZE
	528	void wxGenericFontDialog::OnChangeSize(wxSpinEvent& WXUNUSED(event))
	529	{
	530	DoChangeFont();
	531	}
	532	#endif
	533
	534	const wxChar *wxFontWeightIntToString(int weight)
	535	{
	536	switch (weight)
	537	{
	538	case wxLIGHT:
	539	return wxT("Light");
	540	case wxBOLD:
	541	return wxT("Bold");
	542	case wxNORMAL:
	543	default:
	544	return wxT("Normal");
	545	}
	546	}
	547
	548	const wxChar *wxFontStyleIntToString(int style)
	549	{
	550	switch (style)
	551	{
	552	case wxITALIC:
	553	return wxT("Italic");
	554	case wxSLANT:
	555	return wxT("Slant");
	556	case wxNORMAL:
	557	default:
	558	return wxT("Normal");
	559	}
	560	}
	561
	562	const wxChar *wxFontFamilyIntToString(int family)
	563	{
	564	switch (family)
	565	{
	566	case wxROMAN:
	567	return wxT("Roman");
	568	case wxDECORATIVE:
	569	return wxT("Decorative");
	570	case wxMODERN:
	571	return wxT("Modern");
	572	case wxSCRIPT:
	573	return wxT("Script");
	574	case wxTELETYPE:
	575	return wxT("Teletype");
	576	case wxSWISS:
	577	default:
	578	return wxT("Swiss");
	579	}
	580	}
	581
	582	int wxFontFamilyStringToInt(wxChar *family)
	583	{
	584	if (!family)
	585	return wxSWISS;
	586
	587	if (wxStrcmp(family, wxT("Roman")) == 0)
	588	return wxROMAN;
	589	else if (wxStrcmp(family, wxT("Decorative")) == 0)
	590	return wxDECORATIVE;
	591	else if (wxStrcmp(family, wxT("Modern")) == 0)
	592	return wxMODERN;
	593	else if (wxStrcmp(family, wxT("Script")) == 0)
	594	return wxSCRIPT;
	595	else if (wxStrcmp(family, wxT("Teletype")) == 0)
	596	return wxTELETYPE;
	597	else return wxSWISS;
	598	}
	599
	600	int wxFontStyleStringToInt(wxChar *style)
	601	{
	602	if (!style)
	603	return wxNORMAL;
	604	if (wxStrcmp(style, wxT("Italic")) == 0)
	605	return wxITALIC;
	606	else if (wxStrcmp(style, wxT("Slant")) == 0)
	607	return wxSLANT;
	608	else
	609	return wxNORMAL;
	610	}
	611
	612	int wxFontWeightStringToInt(wxChar *weight)
	613	{
	614	if (!weight)
	615	return wxNORMAL;
	616	if (wxStrcmp(weight, wxT("Bold")) == 0)
	617	return wxBOLD;
	618	else if (wxStrcmp(weight, wxT("Light")) == 0)
	619	return wxLIGHT;
	620	else
	621	return wxNORMAL;
	622	}
	623
	624	#endif
	625	// wxUSE_FONTDLG