wxPython/src/_font.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _font.i
// Purpose:     SWIG interface file for wxFont and related classes
//
// Author:      Robin Dunn
//
// Created:     1-Apr-2002
// RCS-ID:      $Id$
// Copyright:   (c) 2002 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


//---------------------------------------------------------------------------

%{
#include <wx/fontutil.h>
#include <wx/fontmap.h>
#include <wx/fontenum.h>
%}

//---------------------------------------------------------------------------
%newgroup


enum wxFontFamily
{
    wxFONTFAMILY_DEFAULT = wxDEFAULT,
    wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
    wxFONTFAMILY_ROMAN = wxROMAN,
    wxFONTFAMILY_SCRIPT = wxSCRIPT,
    wxFONTFAMILY_SWISS = wxSWISS,
    wxFONTFAMILY_MODERN = wxMODERN,
    wxFONTFAMILY_TELETYPE = wxTELETYPE,
    wxFONTFAMILY_MAX,
    wxFONTFAMILY_UNKNOWN = wxFONTFAMILY_MAX
};

// font styles
enum wxFontStyle
{
    wxFONTSTYLE_NORMAL = wxNORMAL,
    wxFONTSTYLE_ITALIC = wxITALIC,
    wxFONTSTYLE_SLANT = wxSLANT,
    wxFONTSTYLE_MAX
};

// font weights
enum wxFontWeight
{
    wxFONTWEIGHT_NORMAL = wxNORMAL,
    wxFONTWEIGHT_LIGHT = wxLIGHT,
    wxFONTWEIGHT_BOLD = wxBOLD,
    wxFONTWEIGHT_MAX
};


// the font flag bits for the new font ctor accepting one combined flags word
enum
{
    // no special flags: font with default weight/slant/anti-aliasing
    wxFONTFLAG_DEFAULT          = 0,

    // slant flags (default: no slant)
    wxFONTFLAG_ITALIC           = 1 << 0,
    wxFONTFLAG_SLANT            = 1 << 1,

    // weight flags (default: medium)
    wxFONTFLAG_LIGHT            = 1 << 2,
    wxFONTFLAG_BOLD             = 1 << 3,

    // anti-aliasing flag: force on or off (default: the current system default)
    wxFONTFLAG_ANTIALIASED      = 1 << 4,
    wxFONTFLAG_NOT_ANTIALIASED  = 1 << 5,

    // underlined/strikethrough flags (default: no lines)
    wxFONTFLAG_UNDERLINED       = 1 << 6,
    wxFONTFLAG_STRIKETHROUGH    = 1 << 7,

    // the mask of all currently used flags
    wxFONTFLAG_MASK = wxFONTFLAG_ITALIC             |
                      wxFONTFLAG_SLANT              |
                      wxFONTFLAG_LIGHT              |
                      wxFONTFLAG_BOLD               |
                      wxFONTFLAG_ANTIALIASED        |
                      wxFONTFLAG_NOT_ANTIALIASED    |
                      wxFONTFLAG_UNDERLINED         |
                      wxFONTFLAG_STRIKETHROUGH
};


// font encodings
enum wxFontEncoding
{
    wxFONTENCODING_SYSTEM = -1,     // system default
    wxFONTENCODING_DEFAULT,         // current default encoding

    // ISO8859 standard defines a number of single-byte charsets
    wxFONTENCODING_ISO8859_1,       // West European (Latin1)
    wxFONTENCODING_ISO8859_2,       // Central and East European (Latin2)
    wxFONTENCODING_ISO8859_3,       // Esperanto (Latin3)
    wxFONTENCODING_ISO8859_4,       // Baltic (old) (Latin4)
    wxFONTENCODING_ISO8859_5,       // Cyrillic
    wxFONTENCODING_ISO8859_6,       // Arabic
    wxFONTENCODING_ISO8859_7,       // Greek
    wxFONTENCODING_ISO8859_8,       // Hebrew
    wxFONTENCODING_ISO8859_9,       // Turkish (Latin5)
    wxFONTENCODING_ISO8859_10,      // Variation of Latin4 (Latin6)
    wxFONTENCODING_ISO8859_11,      // Thai
    wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
                                    // here anyhow to make all ISO8859
                                    // consecutive numbers
    wxFONTENCODING_ISO8859_13,      // Baltic (Latin7)
    wxFONTENCODING_ISO8859_14,      // Latin8
    wxFONTENCODING_ISO8859_15,      // Latin9 (a.k.a. Latin0, includes euro)
    wxFONTENCODING_ISO8859_MAX,

    // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
    wxFONTENCODING_KOI8,            // KOI8 Russian
    wxFONTENCODING_KOI8_U,          // KOI8 Ukrainian
    wxFONTENCODING_ALTERNATIVE,     // same as MS-DOS CP866
    wxFONTENCODING_BULGARIAN,       // used under Linux in Bulgaria

    // what would we do without Microsoft? They have their own encodings
        // for DOS
    wxFONTENCODING_CP437,           // original MS-DOS codepage
    wxFONTENCODING_CP850,           // CP437 merged with Latin1
    wxFONTENCODING_CP852,           // CP437 merged with Latin2
    wxFONTENCODING_CP855,           // another cyrillic encoding
    wxFONTENCODING_CP866,           // and another one
        // and for Windows
    wxFONTENCODING_CP874,           // WinThai
    wxFONTENCODING_CP932,           // Japanese (shift-JIS)
    wxFONTENCODING_CP936,           // Chinese simplified (GB)
    wxFONTENCODING_CP949,           // Korean (Hangul charset)
    wxFONTENCODING_CP950,           // Chinese (traditional - Big5)
    wxFONTENCODING_CP1250,          // WinLatin2
    wxFONTENCODING_CP1251,          // WinCyrillic
    wxFONTENCODING_CP1252,          // WinLatin1
    wxFONTENCODING_CP1253,          // WinGreek (8859-7)
    wxFONTENCODING_CP1254,          // WinTurkish
    wxFONTENCODING_CP1255,          // WinHebrew
    wxFONTENCODING_CP1256,          // WinArabic
    wxFONTENCODING_CP1257,          // WinBaltic (same as Latin 7)
    wxFONTENCODING_CP12_MAX,

    wxFONTENCODING_UTF7,            // UTF-7 Unicode encoding
    wxFONTENCODING_UTF8,            // UTF-8 Unicode encoding
    wxFONTENCODING_EUC_JP,          // Extended Unix Codepage for Japanese
    wxFONTENCODING_UTF16BE,         // UTF-16 Big Endian Unicode encoding
    wxFONTENCODING_UTF16LE,         // UTF-16 Little Endian Unicode encoding
    wxFONTENCODING_UTF32BE,         // UTF-32 Big Endian Unicode encoding
    wxFONTENCODING_UTF32LE,         // UTF-32 Little Endian Unicode encoding

    wxFONTENCODING_MACROMAN,        // the standard mac encodings
    wxFONTENCODING_MACJAPANESE,
    wxFONTENCODING_MACCHINESETRAD,
    wxFONTENCODING_MACKOREAN,
    wxFONTENCODING_MACARABIC,
    wxFONTENCODING_MACHEBREW,
    wxFONTENCODING_MACGREEK,
    wxFONTENCODING_MACCYRILLIC,
    wxFONTENCODING_MACDEVANAGARI,
    wxFONTENCODING_MACGURMUKHI,
    wxFONTENCODING_MACGUJARATI,
    wxFONTENCODING_MACORIYA,
    wxFONTENCODING_MACBENGALI,
    wxFONTENCODING_MACTAMIL,
    wxFONTENCODING_MACTELUGU,
    wxFONTENCODING_MACKANNADA,
    wxFONTENCODING_MACMALAJALAM,
    wxFONTENCODING_MACSINHALESE,
    wxFONTENCODING_MACBURMESE,
    wxFONTENCODING_MACKHMER,
    wxFONTENCODING_MACTHAI,
    wxFONTENCODING_MACLAOTIAN,
    wxFONTENCODING_MACGEORGIAN,
    wxFONTENCODING_MACARMENIAN,
    wxFONTENCODING_MACCHINESESIMP,
    wxFONTENCODING_MACTIBETAN,
    wxFONTENCODING_MACMONGOLIAN,
    wxFONTENCODING_MACETHIOPIC,
    wxFONTENCODING_MACCENTRALEUR,
    wxFONTENCODING_MACVIATNAMESE,
    wxFONTENCODING_MACARABICEXT,
    wxFONTENCODING_MACSYMBOL,
    wxFONTENCODING_MACDINGBATS,
    wxFONTENCODING_MACTURKISH,
    wxFONTENCODING_MACCROATIAN,
    wxFONTENCODING_MACICELANDIC,
    wxFONTENCODING_MACROMANIAN,
    wxFONTENCODING_MACCELTIC,
    wxFONTENCODING_MACGAELIC,
    wxFONTENCODING_MACKEYBOARD,

    wxFONTENCODING_MACMIN = wxFONTENCODING_MACROMAN ,
    wxFONTENCODING_MACMAX = wxFONTENCODING_MACKEYBOARD ,

    wxFONTENCODING_MAX,             // highest enumerated encoding value


    // aliases for endian-dependent UTF encodings
    wxFONTENCODING_UTF16,  // native UTF-16
    wxFONTENCODING_UTF32,  // native UTF-32

    // alias for the native Unicode encoding on this platform
    // (this is used by wxEncodingConverter and wxUTFFile only for now)
    wxFONTENCODING_UNICODE = wxFONTENCODING_UTF16,

    // alternative names for Far Eastern encodings
        // Chinese
    wxFONTENCODING_GB2312 = wxFONTENCODING_CP936, // Simplified Chinese
    wxFONTENCODING_BIG5 = wxFONTENCODING_CP950,   // Traditional Chinese

        // Japanese (see http://zsigri.tripod.com/fontboard/cjk/jis.html)
    wxFONTENCODING_SHIFT_JIS = wxFONTENCODING_CP932 // Shift JIS
};

//---------------------------------------------------------------------------
%newgroup

// wxNativeFontInfo is platform-specific font representation: this struct
// should be considered as opaque font description only used by the native
// functions, the user code can only get the objects of this type from
// somewhere and pass it somewhere else (possibly save them somewhere using
// ToString() and restore them using FromString())
struct wxNativeFontInfo
{
public:
    wxNativeFontInfo();
    ~wxNativeFontInfo();

    // reset to the default state
    void Init();

    // init with the parameters of the given font
    void InitFromFont(const wxFont& font);

    // accessors and modifiers for the font elements
    int GetPointSize() const;
    wxFontStyle GetStyle() const;
    wxFontWeight GetWeight() const;
    bool GetUnderlined() const;
    wxString GetFaceName() const;
    wxFontFamily GetFamily() const;
    wxFontEncoding GetEncoding() const;

    void SetPointSize(int pointsize);
    void SetStyle(wxFontStyle style);
    void SetWeight(wxFontWeight weight);
    void SetUnderlined(bool underlined);
    void SetFaceName(wxString facename);
    void SetFamily(wxFontFamily family);
    void SetEncoding(wxFontEncoding encoding);

    // it is important to be able to serialize wxNativeFontInfo objects to be
    // able to store them (in config file, for example)
    bool FromString(const wxString& s);
    wxString ToString() const;

    %extend {
        wxString __str__() {
            return self->ToString();
        }
    }

    // we also want to present the native font descriptions to the user in some
    // human-readable form (it is not platform independent neither, but can
    // hopefully be understood by the user)
    bool FromUserString(const wxString& s);
    wxString ToUserString() const;
};


struct wxNativeEncodingInfo
{
    wxString facename;          // may be empty meaning "any"
    wxFontEncoding encoding;    // so that we know what this struct represents

    wxNativeEncodingInfo();
    ~wxNativeEncodingInfo();

    // this struct is saved in config by wxFontMapper, so it should know to
    // serialise itself (implemented in platform-specific code)
    bool FromString(const wxString& s);
    wxString ToString() const;
};


#ifndef __WXMSW__
// translate a wxFontEncoding into native encoding parameter (defined above),
// returning a wxNativeEncodingInfo if an (exact) match could be found, NULL
// otherwise.
%inline %{
    wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
        static wxNativeEncodingInfo info;
        if ( wxGetNativeFontEncoding(encoding, &info) )
            return &info;
        else
            return NULL;
    }
%}

// test for the existence of the font described by this facename/encoding,
// return True if such font(s) exist, False otherwise
bool wxTestFontEncoding(const wxNativeEncodingInfo& info);

#else

%inline %{
    wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
        { wxPyRaiseNotImplemented(); return NULL; }

    bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
        { wxPyRaiseNotImplemented(); return False; }
%}
#endif

//---------------------------------------------------------------------------
%newgroup

// wxFontMapper manages user-definable correspondence between logical font
// names and the fonts present on the machine.
//
// The default implementations of all functions will ask the user if they are
// not capable of finding the answer themselves and store the answer in a
// config file (configurable via SetConfigXXX functions). This behaviour may
// be disabled by giving the value of False to "interactive" parameter.
// However, the functions will always consult the config file to allow the
// user-defined values override the default logic and there is no way to
// disable this - which shouldn't be ever needed because if "interactive" was
// never True, the config file is never created anyhow.
//
// This is a singleton class, font mapper objects can only be accessed using
// wxFontMapper::Get().

class  wxFontMapper
{
public:
    wxFontMapper();
    ~wxFontMapper();

    // return instance of the wxFontMapper singleton
    static wxFontMapper *Get();
    // set the sigleton to 'mapper' instance and return previous one
    static wxFontMapper *Set(wxFontMapper *mapper);


    // returns the encoding for the given charset (in the form of RFC 2046) or
    // wxFONTENCODING_SYSTEM if couldn't decode it
    //
    // interactive parameter is ignored in the base class, we behave as if it
    // were always False
    virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
                                             bool interactive = True);


    // get the number of font encodings we know about
    static size_t GetSupportedEncodingsCount();

    // get the n-th supported encoding
    static wxFontEncoding GetEncoding(size_t n);

    // return internal string identifier for the encoding (see also
    // GetEncodingDescription())
    static wxString GetEncodingName(wxFontEncoding encoding);

    // return user-readable string describing the given encoding
    //
    // NB: hard-coded now, but might change later (read it from config?)
    static wxString GetEncodingDescription(wxFontEncoding encoding);

    // find the encoding corresponding to the given name, inverse of
    // GetEncodingName() and less general than CharsetToEncoding()
    //
    // returns wxFONTENCODING_MAX if the name is not a supported encoding
    static wxFontEncoding GetEncodingFromName(const wxString& name);


    // set the config object to use (may be NULL to use default)
    void SetConfig(wxConfigBase *config);

    // set the root config path to use (should be an absolute path)
    void SetConfigPath(const wxString& prefix);

    // return default config path
    static const wxString GetDefaultConfigPath();


    // Find an alternative for the given encoding (which is supposed to not be
    // available on this system). If successful, returns the encoding otherwise
    // returns None.
    %extend {
        PyObject* GetAltForEncoding(wxFontEncoding encoding,
                                    const wxString& facename = wxPyEmptyString,
                                    bool interactive = True) {
            wxFontEncoding alt_enc;
            if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
                return PyInt_FromLong(alt_enc);
            else {
                Py_INCREF(Py_None);
                return Py_None;
            }
        }
    }


    // checks whether given encoding is available in given face or not.
    // If no facename is given (default), return true if it's available in any
    // facename at all.
    bool IsEncodingAvailable(wxFontEncoding encoding,
                             const wxString& facename = wxPyEmptyString);

    // the parent window for modal dialogs
    void SetDialogParent(wxWindow *parent);

    // the title for the dialogs (note that default is quite reasonable)
    void SetDialogTitle(const wxString& title);

};


//---------------------------------------------------------------------------
%newgroup


class wxFont : public wxGDIObject {
public:
    wxFont( int pointSize, int family, int style, int weight,
            bool underline=False, const wxString& face = wxPyEmptyString,
            wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
    ~wxFont();

    %name(FontFromNativeInfo) wxFont(const wxNativeFontInfo& info);
    %extend {
        %name(FontFromNativeInfoString) wxFont(const wxString& info) {
            wxNativeFontInfo nfi;
            nfi.FromString(info);
            return new wxFont(nfi);
        }

        %name(Font2) wxFont(int pointSize,
                              wxFontFamily family,
                              int flags = wxFONTFLAG_DEFAULT,
                              const wxString& face = wxPyEmptyString,
                              wxFontEncoding encoding = wxFONTENCODING_DEFAULT) {
            return wxFont::New(pointSize, family, flags, face, encoding);
        }
    }


    // was the font successfully created?
    bool Ok() const;
    %pythoncode { def __nonzero__(self): return self.Ok() }

    // comparison
    %extend {
        bool __eq__(const wxFont* other) { return other ? (*self == *other) : False; }
        bool __ne__(const wxFont* other) { return other ? (*self != *other) : True;  }
    }

    // accessors: get the font characteristics
    virtual int GetPointSize() const;
    virtual int GetFamily() const;
    virtual int GetStyle() const;
    virtual int GetWeight() const;
    virtual bool GetUnderlined() const;
    virtual wxString GetFaceName() const;
    virtual wxFontEncoding GetEncoding() const;
    virtual const wxNativeFontInfo *GetNativeFontInfo() const;

    virtual bool IsFixedWidth() const;

    wxString GetNativeFontInfoDesc() const;
    wxString GetNativeFontInfoUserDesc() const;

    // change the font characteristics
    virtual void SetPointSize( int pointSize );
    virtual void SetFamily( int family );
    virtual void SetStyle( int style );
    virtual void SetWeight( int weight );
    virtual void SetFaceName( const wxString& faceName );
    virtual void SetUnderlined( bool underlined );
    virtual void SetEncoding(wxFontEncoding encoding);
    void SetNativeFontInfo(const wxNativeFontInfo& info);
    %name(SetNativeFontInfoFromString) void SetNativeFontInfo(const wxString& info);
    void SetNativeFontInfoUserDesc(const wxString& info);

    // translate the fonts into human-readable string (i.e. GetStyleString()
    // will return "wxITALIC" for an italic font, ...)
    wxString GetFamilyString() const;
    wxString GetStyleString() const;
    wxString GetWeightString() const;

    // Unofficial API, don't use
    virtual void SetNoAntiAliasing( bool no = True );
    virtual bool GetNoAntiAliasing();

    // the default encoding is used for creating all fonts with default
    // encoding parameter
    static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
    static void SetDefaultEncoding(wxFontEncoding encoding);
};


//---------------------------------------------------------------------------
%newgroup

// wxFontEnumerator
%{
class wxPyFontEnumerator : public wxFontEnumerator {
public:
    wxPyFontEnumerator() {}
    ~wxPyFontEnumerator() {}

    DEC_PYCALLBACK_BOOL_STRING(OnFacename);
    DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);

    PYPRIVATE;
};

IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);

%}

%name(FontEnumerator) class wxPyFontEnumerator {
public:
    %pythonAppend wxPyFontEnumerator "self._setCallbackInfo(self, FontEnumerator, 0)"

    wxPyFontEnumerator();
    ~wxPyFontEnumerator();
    void _setCallbackInfo(PyObject* self, PyObject* _class, bool incref);

    bool EnumerateFacenames(
        wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all
        bool fixedWidthOnly = False);

    bool EnumerateEncodings(const wxString& facename = wxPyEmptyString);

    //wxArrayString* GetEncodings();
    //wxArrayString* GetFacenames();
    %extend {
        PyObject* GetEncodings() {
            wxArrayString* arr = self->GetEncodings();
            return wxArrayString2PyList_helper(*arr);
        }

        PyObject* GetFacenames() {
            wxArrayString* arr = self->GetFacenames();
            return wxArrayString2PyList_helper(*arr);
        }
    }
};


%init %{
    wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
%}

//---------------------------------------------------------------------------
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _font.i
	3	// Purpose: SWIG interface file for wxFont and related classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 1-Apr-2002
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2002 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
	16	//---------------------------------------------------------------------------
	17
	18	%{
	19	#include <wx/fontutil.h>
	20	#include <wx/fontmap.h>
	21	#include <wx/fontenum.h>
	22	%}
	23
	24	//---------------------------------------------------------------------------
	25	%newgroup
	26
	27
	28	enum wxFontFamily
	29	{
	30	wxFONTFAMILY_DEFAULT = wxDEFAULT,
	31	wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
	32	wxFONTFAMILY_ROMAN = wxROMAN,
	33	wxFONTFAMILY_SCRIPT = wxSCRIPT,
	34	wxFONTFAMILY_SWISS = wxSWISS,
	35	wxFONTFAMILY_MODERN = wxMODERN,
	36	wxFONTFAMILY_TELETYPE = wxTELETYPE,
	37	wxFONTFAMILY_MAX,
	38	wxFONTFAMILY_UNKNOWN = wxFONTFAMILY_MAX
	39	};
	40
	41	// font styles
	42	enum wxFontStyle
	43	{
	44	wxFONTSTYLE_NORMAL = wxNORMAL,
	45	wxFONTSTYLE_ITALIC = wxITALIC,
	46	wxFONTSTYLE_SLANT = wxSLANT,
	47	wxFONTSTYLE_MAX
	48	};
	49
	50	// font weights
	51	enum wxFontWeight
	52	{
	53	wxFONTWEIGHT_NORMAL = wxNORMAL,
	54	wxFONTWEIGHT_LIGHT = wxLIGHT,
	55	wxFONTWEIGHT_BOLD = wxBOLD,
	56	wxFONTWEIGHT_MAX
	57	};
	58
	59
	60	// the font flag bits for the new font ctor accepting one combined flags word
	61	enum
	62	{
	63	// no special flags: font with default weight/slant/anti-aliasing
	64	wxFONTFLAG_DEFAULT = 0,
	65
	66	// slant flags (default: no slant)
	67	wxFONTFLAG_ITALIC = 1 << 0,
	68	wxFONTFLAG_SLANT = 1 << 1,
	69
	70	// weight flags (default: medium)
	71	wxFONTFLAG_LIGHT = 1 << 2,
	72	wxFONTFLAG_BOLD = 1 << 3,
	73
	74	// anti-aliasing flag: force on or off (default: the current system default)
	75	wxFONTFLAG_ANTIALIASED = 1 << 4,
	76	wxFONTFLAG_NOT_ANTIALIASED = 1 << 5,
	77
	78	// underlined/strikethrough flags (default: no lines)
	79	wxFONTFLAG_UNDERLINED = 1 << 6,
	80	wxFONTFLAG_STRIKETHROUGH = 1 << 7,
	81
	82	// the mask of all currently used flags
	83	wxFONTFLAG_MASK = wxFONTFLAG_ITALIC \|
	84	wxFONTFLAG_SLANT \|
	85	wxFONTFLAG_LIGHT \|
	86	wxFONTFLAG_BOLD \|
	87	wxFONTFLAG_ANTIALIASED \|
	88	wxFONTFLAG_NOT_ANTIALIASED \|
	89	wxFONTFLAG_UNDERLINED \|
	90	wxFONTFLAG_STRIKETHROUGH
	91	};
	92
	93
	94	// font encodings
	95	enum wxFontEncoding
	96	{
	97	wxFONTENCODING_SYSTEM = -1, // system default
	98	wxFONTENCODING_DEFAULT, // current default encoding
	99
	100	// ISO8859 standard defines a number of single-byte charsets
	101	wxFONTENCODING_ISO8859_1, // West European (Latin1)
	102	wxFONTENCODING_ISO8859_2, // Central and East European (Latin2)
	103	wxFONTENCODING_ISO8859_3, // Esperanto (Latin3)
	104	wxFONTENCODING_ISO8859_4, // Baltic (old) (Latin4)
	105	wxFONTENCODING_ISO8859_5, // Cyrillic
	106	wxFONTENCODING_ISO8859_6, // Arabic
	107	wxFONTENCODING_ISO8859_7, // Greek
	108	wxFONTENCODING_ISO8859_8, // Hebrew
	109	wxFONTENCODING_ISO8859_9, // Turkish (Latin5)
	110	wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6)
	111	wxFONTENCODING_ISO8859_11, // Thai
	112	wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
	113	// here anyhow to make all ISO8859
	114	// consecutive numbers
	115	wxFONTENCODING_ISO8859_13, // Baltic (Latin7)
	116	wxFONTENCODING_ISO8859_14, // Latin8
	117	wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro)
	118	wxFONTENCODING_ISO8859_MAX,
	119
	120	// Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
	121	wxFONTENCODING_KOI8, // KOI8 Russian
	122	wxFONTENCODING_KOI8_U, // KOI8 Ukrainian
	123	wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866
	124	wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria
	125
	126	// what would we do without Microsoft? They have their own encodings
	127	// for DOS
	128	wxFONTENCODING_CP437, // original MS-DOS codepage
	129	wxFONTENCODING_CP850, // CP437 merged with Latin1
	130	wxFONTENCODING_CP852, // CP437 merged with Latin2
	131	wxFONTENCODING_CP855, // another cyrillic encoding
	132	wxFONTENCODING_CP866, // and another one
	133	// and for Windows
	134	wxFONTENCODING_CP874, // WinThai
	135	wxFONTENCODING_CP932, // Japanese (shift-JIS)
	136	wxFONTENCODING_CP936, // Chinese simplified (GB)
	137	wxFONTENCODING_CP949, // Korean (Hangul charset)
	138	wxFONTENCODING_CP950, // Chinese (traditional - Big5)
	139	wxFONTENCODING_CP1250, // WinLatin2
	140	wxFONTENCODING_CP1251, // WinCyrillic
	141	wxFONTENCODING_CP1252, // WinLatin1
	142	wxFONTENCODING_CP1253, // WinGreek (8859-7)
	143	wxFONTENCODING_CP1254, // WinTurkish
	144	wxFONTENCODING_CP1255, // WinHebrew
	145	wxFONTENCODING_CP1256, // WinArabic
	146	wxFONTENCODING_CP1257, // WinBaltic (same as Latin 7)
	147	wxFONTENCODING_CP12_MAX,
	148
	149	wxFONTENCODING_UTF7, // UTF-7 Unicode encoding
	150	wxFONTENCODING_UTF8, // UTF-8 Unicode encoding
	151	wxFONTENCODING_EUC_JP, // Extended Unix Codepage for Japanese
	152	wxFONTENCODING_UTF16BE, // UTF-16 Big Endian Unicode encoding
	153	wxFONTENCODING_UTF16LE, // UTF-16 Little Endian Unicode encoding
	154	wxFONTENCODING_UTF32BE, // UTF-32 Big Endian Unicode encoding
	155	wxFONTENCODING_UTF32LE, // UTF-32 Little Endian Unicode encoding
	156
	157	wxFONTENCODING_MACROMAN, // the standard mac encodings
	158	wxFONTENCODING_MACJAPANESE,
	159	wxFONTENCODING_MACCHINESETRAD,
	160	wxFONTENCODING_MACKOREAN,
	161	wxFONTENCODING_MACARABIC,
	162	wxFONTENCODING_MACHEBREW,
	163	wxFONTENCODING_MACGREEK,
	164	wxFONTENCODING_MACCYRILLIC,
	165	wxFONTENCODING_MACDEVANAGARI,
	166	wxFONTENCODING_MACGURMUKHI,
	167	wxFONTENCODING_MACGUJARATI,
	168	wxFONTENCODING_MACORIYA,
	169	wxFONTENCODING_MACBENGALI,
	170	wxFONTENCODING_MACTAMIL,
	171	wxFONTENCODING_MACTELUGU,
	172	wxFONTENCODING_MACKANNADA,
	173	wxFONTENCODING_MACMALAJALAM,
	174	wxFONTENCODING_MACSINHALESE,
	175	wxFONTENCODING_MACBURMESE,
	176	wxFONTENCODING_MACKHMER,
	177	wxFONTENCODING_MACTHAI,
	178	wxFONTENCODING_MACLAOTIAN,
	179	wxFONTENCODING_MACGEORGIAN,
	180	wxFONTENCODING_MACARMENIAN,
	181	wxFONTENCODING_MACCHINESESIMP,
	182	wxFONTENCODING_MACTIBETAN,
	183	wxFONTENCODING_MACMONGOLIAN,
	184	wxFONTENCODING_MACETHIOPIC,
	185	wxFONTENCODING_MACCENTRALEUR,
	186	wxFONTENCODING_MACVIATNAMESE,
	187	wxFONTENCODING_MACARABICEXT,
	188	wxFONTENCODING_MACSYMBOL,
	189	wxFONTENCODING_MACDINGBATS,
	190	wxFONTENCODING_MACTURKISH,
	191	wxFONTENCODING_MACCROATIAN,
	192	wxFONTENCODING_MACICELANDIC,
	193	wxFONTENCODING_MACROMANIAN,
	194	wxFONTENCODING_MACCELTIC,
	195	wxFONTENCODING_MACGAELIC,
	196	wxFONTENCODING_MACKEYBOARD,
	197
	198	wxFONTENCODING_MACMIN = wxFONTENCODING_MACROMAN ,
	199	wxFONTENCODING_MACMAX = wxFONTENCODING_MACKEYBOARD ,
	200
	201	wxFONTENCODING_MAX, // highest enumerated encoding value
	202
	203
	204	// aliases for endian-dependent UTF encodings
	205	wxFONTENCODING_UTF16, // native UTF-16
	206	wxFONTENCODING_UTF32, // native UTF-32
	207
	208	// alias for the native Unicode encoding on this platform
	209	// (this is used by wxEncodingConverter and wxUTFFile only for now)
	210	wxFONTENCODING_UNICODE = wxFONTENCODING_UTF16,
	211
	212	// alternative names for Far Eastern encodings
	213	// Chinese
	214	wxFONTENCODING_GB2312 = wxFONTENCODING_CP936, // Simplified Chinese
	215	wxFONTENCODING_BIG5 = wxFONTENCODING_CP950, // Traditional Chinese
	216
	217	// Japanese (see http://zsigri.tripod.com/fontboard/cjk/jis.html)
	218	wxFONTENCODING_SHIFT_JIS = wxFONTENCODING_CP932 // Shift JIS
	219	};
	220
	221	//---------------------------------------------------------------------------
	222	%newgroup
	223
	224	// wxNativeFontInfo is platform-specific font representation: this struct
	225	// should be considered as opaque font description only used by the native
	226	// functions, the user code can only get the objects of this type from
	227	// somewhere and pass it somewhere else (possibly save them somewhere using
	228	// ToString() and restore them using FromString())
	229	struct wxNativeFontInfo
	230	{
	231	public:
	232	wxNativeFontInfo();
	233	~wxNativeFontInfo();
	234
	235	// reset to the default state
	236	void Init();
	237
	238	// init with the parameters of the given font
	239	void InitFromFont(const wxFont& font);
	240
	241	// accessors and modifiers for the font elements
	242	int GetPointSize() const;
	243	wxFontStyle GetStyle() const;
	244	wxFontWeight GetWeight() const;
	245	bool GetUnderlined() const;
	246	wxString GetFaceName() const;
	247	wxFontFamily GetFamily() const;
	248	wxFontEncoding GetEncoding() const;
	249
	250	void SetPointSize(int pointsize);
	251	void SetStyle(wxFontStyle style);
	252	void SetWeight(wxFontWeight weight);
	253	void SetUnderlined(bool underlined);
	254	void SetFaceName(wxString facename);
	255	void SetFamily(wxFontFamily family);
	256	void SetEncoding(wxFontEncoding encoding);
	257
	258	// it is important to be able to serialize wxNativeFontInfo objects to be
	259	// able to store them (in config file, for example)
	260	bool FromString(const wxString& s);
	261	wxString ToString() const;
	262
	263	%extend {
	264	wxString __str__() {
	265	return self->ToString();
	266	}
	267	}
	268
	269	// we also want to present the native font descriptions to the user in some
	270	// human-readable form (it is not platform independent neither, but can
	271	// hopefully be understood by the user)
	272	bool FromUserString(const wxString& s);
	273	wxString ToUserString() const;
	274	};
	275
	276
	277
	278
	279	struct wxNativeEncodingInfo
	280	{
	281	wxString facename; // may be empty meaning "any"
	282	wxFontEncoding encoding; // so that we know what this struct represents
	283
	284	wxNativeEncodingInfo();
	285	~wxNativeEncodingInfo();
	286
	287	// this struct is saved in config by wxFontMapper, so it should know to
	288	// serialise itself (implemented in platform-specific code)
	289	bool FromString(const wxString& s);
	290	wxString ToString() const;
	291	};
	292
	293
	294	#ifndef __WXMSW__
	295	// translate a wxFontEncoding into native encoding parameter (defined above),
	296	// returning a wxNativeEncodingInfo if an (exact) match could be found, NULL
	297	// otherwise.
	298	%inline %{
	299	wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding) {
	300	static wxNativeEncodingInfo info;
	301	if ( wxGetNativeFontEncoding(encoding, &info) )
	302	return &info;
	303	else
	304	return NULL;
	305	}
	306	%}
	307
	308	// test for the existence of the font described by this facename/encoding,
	309	// return True if such font(s) exist, False otherwise
	310	bool wxTestFontEncoding(const wxNativeEncodingInfo& info);
	311
	312	#else
	313
	314	%inline %{
	315	wxNativeEncodingInfo* wxGetNativeFontEncoding(wxFontEncoding encoding)
	316	{ wxPyRaiseNotImplemented(); return NULL; }
	317
	318	bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
	319	{ wxPyRaiseNotImplemented(); return False; }
	320	%}
	321	#endif
	322
	323	//---------------------------------------------------------------------------
	324	%newgroup
	325
	326	// wxFontMapper manages user-definable correspondence between logical font
	327	// names and the fonts present on the machine.
	328	//
	329	// The default implementations of all functions will ask the user if they are
	330	// not capable of finding the answer themselves and store the answer in a
	331	// config file (configurable via SetConfigXXX functions). This behaviour may
	332	// be disabled by giving the value of False to "interactive" parameter.
	333	// However, the functions will always consult the config file to allow the
	334	// user-defined values override the default logic and there is no way to
	335	// disable this - which shouldn't be ever needed because if "interactive" was
	336	// never True, the config file is never created anyhow.
	337	//
	338	// This is a singleton class, font mapper objects can only be accessed using
	339	// wxFontMapper::Get().
	340
	341	class wxFontMapper
	342	{
	343	public:
	344	wxFontMapper();
	345	~wxFontMapper();
	346
	347	// return instance of the wxFontMapper singleton
	348	static wxFontMapper *Get();
	349	// set the sigleton to 'mapper' instance and return previous one
	350	static wxFontMapper Set(wxFontMapper mapper);
	351
	352
	353	// returns the encoding for the given charset (in the form of RFC 2046) or
	354	// wxFONTENCODING_SYSTEM if couldn't decode it
	355	//
	356	// interactive parameter is ignored in the base class, we behave as if it
	357	// were always False
	358	virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
	359	bool interactive = True);
	360
	361
	362	// get the number of font encodings we know about
	363	static size_t GetSupportedEncodingsCount();
	364
	365	// get the n-th supported encoding
	366	static wxFontEncoding GetEncoding(size_t n);
	367
	368	// return internal string identifier for the encoding (see also
	369	// GetEncodingDescription())
	370	static wxString GetEncodingName(wxFontEncoding encoding);
	371
	372	// return user-readable string describing the given encoding
	373	//
	374	// NB: hard-coded now, but might change later (read it from config?)
	375	static wxString GetEncodingDescription(wxFontEncoding encoding);
	376
	377	// find the encoding corresponding to the given name, inverse of
	378	// GetEncodingName() and less general than CharsetToEncoding()
	379	//
	380	// returns wxFONTENCODING_MAX if the name is not a supported encoding
	381	static wxFontEncoding GetEncodingFromName(const wxString& name);
	382
	383
	384	// set the config object to use (may be NULL to use default)
	385	void SetConfig(wxConfigBase *config);
	386
	387	// set the root config path to use (should be an absolute path)
	388	void SetConfigPath(const wxString& prefix);
	389
	390	// return default config path
	391	static const wxString GetDefaultConfigPath();
	392
	393
	394
	395	// Find an alternative for the given encoding (which is supposed to not be
	396	// available on this system). If successful, returns the encoding otherwise
	397	// returns None.
	398	%extend {
	399	PyObject* GetAltForEncoding(wxFontEncoding encoding,
	400	const wxString& facename = wxPyEmptyString,
	401	bool interactive = True) {
	402	wxFontEncoding alt_enc;
	403	if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
	404	return PyInt_FromLong(alt_enc);
	405	else {
	406	Py_INCREF(Py_None);
	407	return Py_None;
	408	}
	409	}
	410	}
	411
	412
	413	// checks whether given encoding is available in given face or not.
	414	// If no facename is given (default), return true if it's available in any
	415	// facename at all.
	416	bool IsEncodingAvailable(wxFontEncoding encoding,
	417	const wxString& facename = wxPyEmptyString);
	418
	419	// the parent window for modal dialogs
	420	void SetDialogParent(wxWindow *parent);
	421
	422	// the title for the dialogs (note that default is quite reasonable)
	423	void SetDialogTitle(const wxString& title);
	424
	425	};
	426
	427
	428
	429	//---------------------------------------------------------------------------
	430	%newgroup
	431
	432
	433	class wxFont : public wxGDIObject {
	434	public:
	435	wxFont( int pointSize, int family, int style, int weight,
	436	bool underline=False, const wxString& face = wxPyEmptyString,
	437	wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
	438	~wxFont();
	439
	440	%name(FontFromNativeInfo) wxFont(const wxNativeFontInfo& info);
	441	%extend {
	442	%name(FontFromNativeInfoString) wxFont(const wxString& info) {
	443	wxNativeFontInfo nfi;
	444	nfi.FromString(info);
	445	return new wxFont(nfi);
	446	}
	447
	448	%name(Font2) wxFont(int pointSize,
	449	wxFontFamily family,
	450	int flags = wxFONTFLAG_DEFAULT,
	451	const wxString& face = wxPyEmptyString,
	452	wxFontEncoding encoding = wxFONTENCODING_DEFAULT) {
	453	return wxFont::New(pointSize, family, flags, face, encoding);
	454	}
	455	}
	456
	457
	458	// was the font successfully created?
	459	bool Ok() const;
	460	%pythoncode { def __nonzero__(self): return self.Ok() }
	461
	462	// comparison
	463	%extend {
	464	bool __eq__(const wxFont* other) { return other ? (self == other) : False; }
	465	bool __ne__(const wxFont* other) { return other ? (self != other) : True; }
	466	}
	467
	468	// accessors: get the font characteristics
	469	virtual int GetPointSize() const;
	470	virtual int GetFamily() const;
	471	virtual int GetStyle() const;
	472	virtual int GetWeight() const;
	473	virtual bool GetUnderlined() const;
	474	virtual wxString GetFaceName() const;
	475	virtual wxFontEncoding GetEncoding() const;
	476	virtual const wxNativeFontInfo *GetNativeFontInfo() const;
	477
	478	virtual bool IsFixedWidth() const;
	479
	480	wxString GetNativeFontInfoDesc() const;
	481	wxString GetNativeFontInfoUserDesc() const;
	482
	483	// change the font characteristics
	484	virtual void SetPointSize( int pointSize );
	485	virtual void SetFamily( int family );
	486	virtual void SetStyle( int style );
	487	virtual void SetWeight( int weight );
	488	virtual void SetFaceName( const wxString& faceName );
	489	virtual void SetUnderlined( bool underlined );
	490	virtual void SetEncoding(wxFontEncoding encoding);
	491	void SetNativeFontInfo(const wxNativeFontInfo& info);
	492	%name(SetNativeFontInfoFromString) void SetNativeFontInfo(const wxString& info);
	493	void SetNativeFontInfoUserDesc(const wxString& info);
	494
	495	// translate the fonts into human-readable string (i.e. GetStyleString()
	496	// will return "wxITALIC" for an italic font, ...)
	497	wxString GetFamilyString() const;
	498	wxString GetStyleString() const;
	499	wxString GetWeightString() const;
	500
	501	// Unofficial API, don't use
	502	virtual void SetNoAntiAliasing( bool no = True );
	503	virtual bool GetNoAntiAliasing();
	504
	505	// the default encoding is used for creating all fonts with default
	506	// encoding parameter
	507	static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
	508	static void SetDefaultEncoding(wxFontEncoding encoding);
	509	};
	510
	511
	512
	513	//---------------------------------------------------------------------------
	514	%newgroup
	515
	516	// wxFontEnumerator
	517	%{
	518	class wxPyFontEnumerator : public wxFontEnumerator {
	519	public:
	520	wxPyFontEnumerator() {}
	521	~wxPyFontEnumerator() {}
	522
	523	DEC_PYCALLBACK_BOOL_STRING(OnFacename);
	524	DEC_PYCALLBACK_BOOL_STRINGSTRING(OnFontEncoding);
	525
	526	PYPRIVATE;
	527	};
	528
	529	IMP_PYCALLBACK_BOOL_STRING(wxPyFontEnumerator, wxFontEnumerator, OnFacename);
	530	IMP_PYCALLBACK_BOOL_STRINGSTRING(wxPyFontEnumerator, wxFontEnumerator, OnFontEncoding);
	531
	532	%}
	533
	534	%name(FontEnumerator) class wxPyFontEnumerator {
	535	public:
	536	%pythonAppend wxPyFontEnumerator "self._setCallbackInfo(self, FontEnumerator, 0)"
	537
	538	wxPyFontEnumerator();
	539	~wxPyFontEnumerator();
	540	void _setCallbackInfo(PyObject* self, PyObject* _class, bool incref);
	541
	542	bool EnumerateFacenames(
	543	wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all
	544	bool fixedWidthOnly = False);
	545
	546	bool EnumerateEncodings(const wxString& facename = wxPyEmptyString);
	547
	548	//wxArrayString* GetEncodings();
	549	//wxArrayString* GetFacenames();
	550	%extend {
	551	PyObject* GetEncodings() {
	552	wxArrayString* arr = self->GetEncodings();
	553	return wxArrayString2PyList_helper(*arr);
	554	}
	555
	556	PyObject* GetFacenames() {
	557	wxArrayString* arr = self->GetFacenames();
	558	return wxArrayString2PyList_helper(*arr);
	559	}
	560	}
	561	};
	562
	563
	564
	565	%init %{
	566	wxPyPtrTypeMap_Add("wxFontEnumerator", "wxPyFontEnumerator");
	567	%}
	568
	569	//---------------------------------------------------------------------------