include/wx/font.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/font.h
   3 // Purpose:     wxFontBase class: the interface of wxFont
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.09.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_FONT_H_BASE_
  13 #define _WX_FONT_H_BASE_
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 #include "wx/defs.h"        // for wxDEFAULT &c
  20 #include "wx/fontenc.h"     // the font encoding constants
  21 #include "wx/gdiobj.h"      // the base class
  22 #include "wx/gdicmn.h"      // for wxGDIObjListBase
  23
  24 // ----------------------------------------------------------------------------
  25 // forward declarations
  26 // ----------------------------------------------------------------------------
  27
  28 class WXDLLIMPEXP_FWD_CORE wxFont;
  29
  30 // ----------------------------------------------------------------------------
  31 // font constants
  32 // ----------------------------------------------------------------------------
  33
  34 // standard font families: these may be used only for the font creation, it
  35 // doesn't make sense to query an existing font for its font family as,
  36 // especially if the font had been created from a native font description, it
  37 // may be unknown
  38 enum wxFontFamily
  39 {
  40     wxFONTFAMILY_DEFAULT = wxDEFAULT,
  41     wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
  42     wxFONTFAMILY_ROMAN = wxROMAN,
  43     wxFONTFAMILY_SCRIPT = wxSCRIPT,
  44     wxFONTFAMILY_SWISS = wxSWISS,
  45     wxFONTFAMILY_MODERN = wxMODERN,
  46     wxFONTFAMILY_TELETYPE = wxTELETYPE,
  47     wxFONTFAMILY_MAX,
  48     wxFONTFAMILY_UNKNOWN = wxFONTFAMILY_MAX
  49 };
  50
  51 // font styles
  52 enum wxFontStyle
  53 {
  54     wxFONTSTYLE_NORMAL = wxNORMAL,
  55     wxFONTSTYLE_ITALIC = wxITALIC,
  56     wxFONTSTYLE_SLANT = wxSLANT,
  57     wxFONTSTYLE_MAX
  58 };
  59
  60 // font weights
  61 enum wxFontWeight
  62 {
  63     wxFONTWEIGHT_NORMAL = wxNORMAL,
  64     wxFONTWEIGHT_LIGHT = wxLIGHT,
  65     wxFONTWEIGHT_BOLD = wxBOLD,
  66     wxFONTWEIGHT_MAX
  67 };
  68
  69 // Symbolic font sizes as defined in CSS specification.
  70 enum wxFontSymbolicSize
  71 {
  72     wxFONTSIZE_XX_SMALL = -3,
  73     wxFONTSIZE_X_SMALL,
  74     wxFONTSIZE_SMALL,
  75     wxFONTSIZE_MEDIUM,
  76     wxFONTSIZE_LARGE,
  77     wxFONTSIZE_X_LARGE,
  78     wxFONTSIZE_XX_LARGE
  79 };
  80
  81 // the font flag bits for the new font ctor accepting one combined flags word
  82 enum wxFontFlag
  83 {
  84     // no special flags: font with default weight/slant/anti-aliasing
  85     wxFONTFLAG_DEFAULT          = 0,
  86
  87     // slant flags (default: no slant)
  88     wxFONTFLAG_ITALIC           = 1 << 0,
  89     wxFONTFLAG_SLANT            = 1 << 1,
  90
  91     // weight flags (default: medium)
  92     wxFONTFLAG_LIGHT            = 1 << 2,
  93     wxFONTFLAG_BOLD             = 1 << 3,
  94
  95     // anti-aliasing flag: force on or off (default: the current system default)
  96     wxFONTFLAG_ANTIALIASED      = 1 << 4,
  97     wxFONTFLAG_NOT_ANTIALIASED  = 1 << 5,
  98
  99     // underlined/strikethrough flags (default: no lines)
 100     wxFONTFLAG_UNDERLINED       = 1 << 6,
 101     wxFONTFLAG_STRIKETHROUGH    = 1 << 7,
 102
 103     // the mask of all currently used flags
 104     wxFONTFLAG_MASK = wxFONTFLAG_ITALIC             |
 105                       wxFONTFLAG_SLANT              |
 106                       wxFONTFLAG_LIGHT              |
 107                       wxFONTFLAG_BOLD               |
 108                       wxFONTFLAG_ANTIALIASED        |
 109                       wxFONTFLAG_NOT_ANTIALIASED    |
 110                       wxFONTFLAG_UNDERLINED         |
 111                       wxFONTFLAG_STRIKETHROUGH
 112 };
 113
 114 // ----------------------------------------------------------------------------
 115 // wxFontBase represents a font object
 116 // ----------------------------------------------------------------------------
 117
 118 class WXDLLIMPEXP_FWD_CORE wxNativeFontInfo;
 119
 120 class WXDLLIMPEXP_CORE wxFontBase : public wxGDIObject
 121 {
 122 public:
 123     /*
 124         derived classes should provide the following ctors:
 125
 126     wxFont();
 127     wxFont(const wxString& nativeFontInfoString);
 128     wxFont(const wxNativeFontInfo& info);
 129     wxFont(int size,
 130            wxFontFamily family,
 131            wxFontStyle style,
 132            wxFontWeight weight,
 133            bool underlined = false,
 134            const wxString& face = wxEmptyString,
 135            wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 136     wxFont(const wxSize& pixelSize,
 137            wxFontFamily family,
 138            wxFontStyle style,
 139            wxFontWeight weight,
 140            bool underlined = false,
 141            const wxString& face = wxEmptyString,
 142            wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 143     */
 144
 145     // creator function
 146     virtual ~wxFontBase();
 147
 148
 149 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 150     // from the font components
 151     static wxFont *New(
 152         int pointSize,              // size of the font in points
 153         int family,                 // see wxFontFamily enum
 154         int style,                  // see wxFontStyle enum
 155         int weight,                 // see wxFontWeight enum
 156         bool underlined = false,    // not underlined by default
 157         const wxString& face = wxEmptyString,              // facename
 158         wxFontEncoding encoding = wxFONTENCODING_DEFAULT)  // ISO8859-X, ...
 159         { return New(pointSize, (wxFontFamily)family, (wxFontStyle)style,
 160                      (wxFontWeight)weight, underlined, face, encoding); }
 161
 162     // from the font components
 163     static wxFont *New(
 164         const wxSize& pixelSize,    // size of the font in pixels
 165         int family,                 // see wxFontFamily enum
 166         int style,                  // see wxFontStyle enum
 167         int weight,                 // see wxFontWeight enum
 168         bool underlined = false,    // not underlined by default
 169         const wxString& face = wxEmptyString,              // facename
 170         wxFontEncoding encoding = wxFONTENCODING_DEFAULT)  // ISO8859-X, ...
 171         { return New(pixelSize, (wxFontFamily)family, (wxFontStyle)style,
 172                      (wxFontWeight)weight, underlined, face, encoding); }
 173 #endif
 174
 175     // from the font components
 176     static wxFont *New(
 177         int pointSize,              // size of the font in points
 178         wxFontFamily family,        // see wxFontFamily enum
 179         wxFontStyle style,          // see wxFontStyle enum
 180         wxFontWeight weight,        // see wxFontWeight enum
 181         bool underlined = false,    // not underlined by default
 182         const wxString& face = wxEmptyString,              // facename
 183         wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
 184
 185     // from the font components
 186     static wxFont *New(
 187         const wxSize& pixelSize,    // size of the font in pixels
 188         wxFontFamily family,        // see wxFontFamily enum
 189         wxFontStyle style,          // see wxFontStyle enum
 190         wxFontWeight weight,        // see wxFontWeight enum
 191         bool underlined = false,    // not underlined by default
 192         const wxString& face = wxEmptyString,              // facename
 193         wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
 194
 195     // from the font components but using the font flags instead of separate
 196     // parameters for each flag
 197     static wxFont *New(int pointSize,
 198                        wxFontFamily family,
 199                        int flags = wxFONTFLAG_DEFAULT,
 200                        const wxString& face = wxEmptyString,
 201                        wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 202
 203
 204     // from the font components but using the font flags instead of separate
 205     // parameters for each flag
 206     static wxFont *New(const wxSize& pixelSize,
 207                        wxFontFamily family,
 208                        int flags = wxFONTFLAG_DEFAULT,
 209                        const wxString& face = wxEmptyString,
 210                        wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 211
 212     // from the (opaque) native font description object
 213     static wxFont *New(const wxNativeFontInfo& nativeFontDesc);
 214
 215     // from the string representation of wxNativeFontInfo
 216     static wxFont *New(const wxString& strNativeFontDesc);
 217
 218     // comparison
 219     bool operator==(const wxFont& font) const;
 220     bool operator!=(const wxFont& font) const { return !(*this == font); }
 221
 222     // accessors: get the font characteristics
 223     virtual int GetPointSize() const = 0;
 224     virtual wxSize GetPixelSize() const;
 225     virtual bool IsUsingSizeInPixels() const;
 226     wxFontFamily GetFamily() const;
 227     virtual wxFontStyle GetStyle() const = 0;
 228     virtual wxFontWeight GetWeight() const = 0;
 229     virtual bool GetUnderlined() const = 0;
 230     virtual wxString GetFaceName() const = 0;
 231     virtual wxFontEncoding GetEncoding() const = 0;
 232     virtual const wxNativeFontInfo *GetNativeFontInfo() const = 0;
 233
 234     virtual bool IsFixedWidth() const;
 235
 236     wxString GetNativeFontInfoDesc() const;
 237     wxString GetNativeFontInfoUserDesc() const;
 238
 239     // change the font characteristics
 240     virtual void SetPointSize( int pointSize ) = 0;
 241     virtual void SetPixelSize( const wxSize& pixelSize );
 242     virtual void SetFamily( wxFontFamily family ) = 0;
 243     virtual void SetStyle( wxFontStyle style ) = 0;
 244     virtual void SetWeight( wxFontWeight weight ) = 0;
 245
 246     virtual void SetUnderlined( bool underlined ) = 0;
 247     virtual void SetEncoding(wxFontEncoding encoding) = 0;
 248     virtual bool SetFaceName( const wxString& faceName );
 249     void SetNativeFontInfo(const wxNativeFontInfo& info)
 250         { DoSetNativeFontInfo(info); }
 251
 252     bool SetNativeFontInfo(const wxString& info);
 253     bool SetNativeFontInfoUserDesc(const wxString& info);
 254
 255     // Symbolic font sizes support: set the font size to "large" or "very
 256     // small" either absolutely (i.e. compared to the default font size) or
 257     // relatively to the given font size.
 258     void SetSymbolicSize(wxFontSymbolicSize size);
 259     void SetSymbolicSizeRelativeTo(wxFontSymbolicSize size, int base)
 260     {
 261         SetPointSize(AdjustToSymbolicSize(size, base));
 262     }
 263
 264     // Adjust the base size in points according to symbolic size.
 265     static int AdjustToSymbolicSize(wxFontSymbolicSize size, int base);
 266
 267
 268     // translate the fonts into human-readable string (i.e. GetStyleString()
 269     // will return "wxITALIC" for an italic font, ...)
 270     wxString GetFamilyString() const;
 271     wxString GetStyleString() const;
 272     wxString GetWeightString() const;
 273
 274     // the default encoding is used for creating all fonts with default
 275     // encoding parameter
 276     static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
 277     static void SetDefaultEncoding(wxFontEncoding encoding);
 278
 279     // this doesn't do anything and is kept for compatibility only
 280 #if WXWIN_COMPATIBILITY_2_8
 281     wxDEPRECATED_INLINE(void SetNoAntiAliasing(bool no = true), wxUnusedVar(no););
 282     wxDEPRECATED_INLINE(bool GetNoAntiAliasing() const, return false;)
 283 #endif // WXWIN_COMPATIBILITY_2_8
 284
 285 protected:
 286     // the function called by both overloads of SetNativeFontInfo()
 287     virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info);
 288
 289     // The function called by public GetFamily(): it can return
 290     // wxFONTFAMILY_UNKNOWN unlike the public method (see comment there).
 291     virtual wxFontFamily DoGetFamily() const = 0;
 292
 293 private:
 294     // the currently default encoding: by default, it's the default system
 295     // encoding, but may be changed by the application using
 296     // SetDefaultEncoding() to make all subsequent fonts created without
 297     // specifying encoding parameter using this encoding
 298     static wxFontEncoding ms_encodingDefault;
 299 };
 300
 301 // wxFontBase <-> wxString utilities, used by wxConfig
 302 WXDLLIMPEXP_CORE wxString wxToString(const wxFontBase& font);
 303 WXDLLIMPEXP_CORE bool wxFromString(const wxString& str, wxFontBase* font);
 304
 305
 306 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 307 #define wxDECLARE_FONT_COMPAT_SETTER   \
 308     wxDEPRECATED_FUTURE( void SetFamily(int family) ) \
 309         { SetFamily((wxFontFamily)family); } \
 310     wxDEPRECATED_FUTURE( void SetStyle(int style) ) \
 311         { SetStyle((wxFontStyle)style); } \
 312     wxDEPRECATED_FUTURE( void SetWeight(int weight) ) \
 313         { SetWeight((wxFontWeight)weight); } \
 314     wxDEPRECATED_FUTURE( void SetFamily(wxDeprecatedGUIConstants family) ) \
 315         { SetFamily((wxFontFamily)family); } \
 316     wxDEPRECATED_FUTURE( void SetStyle(wxDeprecatedGUIConstants style) ) \
 317         { SetStyle((wxFontStyle)style); } \
 318     wxDEPRECATED_FUTURE( void SetWeight(wxDeprecatedGUIConstants weight) ) \
 319         { SetWeight((wxFontWeight)weight); }
 320 #else
 321 #define wxDECLARE_FONT_COMPAT_SETTER  /*empty*/
 322 #endif
 323
 324 // this macro must be used in all derived wxFont classes declarations
 325 #define wxDECLARE_COMMON_FONT_METHODS() \
 326     wxDECLARE_FONT_COMPAT_SETTER \
 327  \
 328     /* functions for modifying font in place */ \
 329     wxFont& MakeBold(); \
 330     wxFont& MakeItalic(); \
 331     wxFont& MakeUnderlined(); \
 332     wxFont& MakeLarger() { return Scale(1.2f); } \
 333     wxFont& MakeSmaller() { return Scale(1/1.2f); } \
 334     wxFont& Scale(float x); \
 335     /* functions for creating fonts based on this one */ \
 336     wxFont Bold() const; \
 337     wxFont Italic() const; \
 338     wxFont Underlined() const; \
 339     wxFont Larger() const { return Scaled(1.2f); } \
 340     wxFont Smaller() const { return Scaled(1/1.2f); } \
 341     wxFont Scaled(float x) const
 342
 343 // include the real class declaration
 344 #if defined(__WXMSW__)
 345     #include "wx/msw/font.h"
 346 #elif defined(__WXMOTIF__)
 347     #include "wx/motif/font.h"
 348 #elif defined(__WXGTK20__)
 349     #include "wx/gtk/font.h"
 350 #elif defined(__WXGTK__)
 351     #include "wx/gtk1/font.h"
 352 #elif defined(__WXX11__)
 353     #include "wx/x11/font.h"
 354 #elif defined(__WXDFB__)
 355     #include "wx/dfb/font.h"
 356 #elif defined(__WXMAC__)
 357     #include "wx/osx/font.h"
 358 #elif defined(__WXCOCOA__)
 359     #include "wx/cocoa/font.h"
 360 #elif defined(__WXPM__)
 361     #include "wx/os2/font.h"
 362 #endif
 363
 364 class WXDLLIMPEXP_CORE wxFontList: public wxGDIObjListBase
 365 {
 366 public:
 367     wxFont *FindOrCreateFont(int pointSize,
 368                              wxFontFamily family,
 369                              wxFontStyle style,
 370                              wxFontWeight weight,
 371                              bool underline = false,
 372                              const wxString& face = wxEmptyString,
 373                              wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 374
 375 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 376      wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
 377                               bool underline = false,
 378                               const wxString& face = wxEmptyString,
 379                               wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
 380         { return FindOrCreateFont(pointSize, (wxFontFamily)family, (wxFontStyle)style,
 381                                   (wxFontWeight)weight, underline, face, encoding); }
 382 #endif
 383
 384 #if WXWIN_COMPATIBILITY_2_6
 385     wxDEPRECATED( void AddFont(wxFont*) );
 386     wxDEPRECATED( void RemoveFont(wxFont*) );
 387 #endif
 388 };
 389
 390 extern WXDLLIMPEXP_DATA_CORE(wxFontList*)    wxTheFontList;
 391
 392
 393 // provide comparison operators to allow code such as
 394 //
 395 //      if ( font.GetStyle() == wxFONTSTYLE_SLANT )
 396 //
 397 // to compile without warnings which it would otherwise provoke from some
 398 // compilers as it compares elements of different enums
 399 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 400
 401 // Unfortunately some compilers have ambiguity issues when enum comparisons are
 402 // overloaded so we have to disable the overloads in this case, see
 403 // wxCOMPILER_NO_OVERLOAD_ON_ENUM definition in wx/platform.h for more details.
 404 #ifndef wxCOMPILER_NO_OVERLOAD_ON_ENUM
 405
 406 inline bool operator==(wxFontFamily s, wxDeprecatedGUIConstants t)
 407 { return static_cast<int>(s) == static_cast<int>(t); }
 408 inline bool operator!=(wxFontFamily s, wxDeprecatedGUIConstants t)
 409 { return !(s == t); }
 410 inline bool operator==(wxFontStyle s, wxDeprecatedGUIConstants t)
 411 { return static_cast<int>(s) == static_cast<int>(t); }
 412 inline bool operator!=(wxFontStyle s, wxDeprecatedGUIConstants t)
 413 { return !(s == t); }
 414 inline bool operator==(wxFontWeight s, wxDeprecatedGUIConstants t)
 415 { return static_cast<int>(s) == static_cast<int>(t); }
 416 inline bool operator!=(wxFontWeight s, wxDeprecatedGUIConstants t)
 417 { return !(s == t); }
 418
 419 #endif // // wxCOMPILER_NO_OVERLOAD_ON_ENUM
 420
 421 #endif // FUTURE_WXWIN_COMPATIBILITY_3_0
 422
 423 #endif
 424     // _WX_FONT_H_BASE_