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 bool GetStrikethrough() const { return false; }
 231     virtual wxString GetFaceName() const = 0;
 232     virtual wxFontEncoding GetEncoding() const = 0;
 233     virtual const wxNativeFontInfo *GetNativeFontInfo() const = 0;
 234
 235     virtual bool IsFixedWidth() const;
 236
 237     wxString GetNativeFontInfoDesc() const;
 238     wxString GetNativeFontInfoUserDesc() const;
 239
 240     // change the font characteristics
 241     virtual void SetPointSize( int pointSize ) = 0;
 242     virtual void SetPixelSize( const wxSize& pixelSize );
 243     virtual void SetFamily( wxFontFamily family ) = 0;
 244     virtual void SetStyle( wxFontStyle style ) = 0;
 245     virtual void SetWeight( wxFontWeight weight ) = 0;
 246
 247     virtual void SetUnderlined( bool underlined ) = 0;
 248     virtual void SetStrikethrough( bool WXUNUSED(strikethrough) ) {}
 249     virtual void SetEncoding(wxFontEncoding encoding) = 0;
 250     virtual bool SetFaceName( const wxString& faceName );
 251     void SetNativeFontInfo(const wxNativeFontInfo& info)
 252         { DoSetNativeFontInfo(info); }
 253
 254     bool SetNativeFontInfo(const wxString& info);
 255     bool SetNativeFontInfoUserDesc(const wxString& info);
 256
 257     // Symbolic font sizes support: set the font size to "large" or "very
 258     // small" either absolutely (i.e. compared to the default font size) or
 259     // relatively to the given font size.
 260     void SetSymbolicSize(wxFontSymbolicSize size);
 261     void SetSymbolicSizeRelativeTo(wxFontSymbolicSize size, int base)
 262     {
 263         SetPointSize(AdjustToSymbolicSize(size, base));
 264     }
 265
 266     // Adjust the base size in points according to symbolic size.
 267     static int AdjustToSymbolicSize(wxFontSymbolicSize size, int base);
 268
 269
 270     // translate the fonts into human-readable string (i.e. GetStyleString()
 271     // will return "wxITALIC" for an italic font, ...)
 272     wxString GetFamilyString() const;
 273     wxString GetStyleString() const;
 274     wxString GetWeightString() const;
 275
 276     // the default encoding is used for creating all fonts with default
 277     // encoding parameter
 278     static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
 279     static void SetDefaultEncoding(wxFontEncoding encoding);
 280
 281     // this doesn't do anything and is kept for compatibility only
 282 #if WXWIN_COMPATIBILITY_2_8
 283     wxDEPRECATED_INLINE(void SetNoAntiAliasing(bool no = true), wxUnusedVar(no););
 284     wxDEPRECATED_INLINE(bool GetNoAntiAliasing() const, return false;)
 285 #endif // WXWIN_COMPATIBILITY_2_8
 286
 287 protected:
 288     // the function called by both overloads of SetNativeFontInfo()
 289     virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info);
 290
 291     // The function called by public GetFamily(): it can return
 292     // wxFONTFAMILY_UNKNOWN unlike the public method (see comment there).
 293     virtual wxFontFamily DoGetFamily() const = 0;
 294
 295
 296     // Helper functions to recover wxFONTSTYLE/wxFONTWEIGHT and underlined flg
 297     // values from flags containing a combination of wxFONTFLAG_XXX.
 298     static wxFontStyle GetStyleFromFlags(int flags)
 299     {
 300         return flags & wxFONTFLAG_ITALIC
 301                         ? wxFONTSTYLE_ITALIC
 302                         : flags & wxFONTFLAG_SLANT
 303                             ? wxFONTSTYLE_SLANT
 304                             : wxFONTSTYLE_NORMAL;
 305     }
 306
 307     static wxFontWeight GetWeightFromFlags(int flags)
 308     {
 309         return flags & wxFONTFLAG_LIGHT
 310                         ? wxFONTWEIGHT_LIGHT
 311                         : flags & wxFONTFLAG_BOLD
 312                             ? wxFONTWEIGHT_BOLD
 313                             : wxFONTWEIGHT_NORMAL;
 314     }
 315
 316     static bool GetUnderlinedFromFlags(int flags)
 317     {
 318         return (flags & wxFONTFLAG_UNDERLINED) != 0;
 319     }
 320
 321
 322 private:
 323     // the currently default encoding: by default, it's the default system
 324     // encoding, but may be changed by the application using
 325     // SetDefaultEncoding() to make all subsequent fonts created without
 326     // specifying encoding parameter using this encoding
 327     static wxFontEncoding ms_encodingDefault;
 328 };
 329
 330 // wxFontBase <-> wxString utilities, used by wxConfig
 331 WXDLLIMPEXP_CORE wxString wxToString(const wxFontBase& font);
 332 WXDLLIMPEXP_CORE bool wxFromString(const wxString& str, wxFontBase* font);
 333
 334
 335 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 336 #define wxDECLARE_FONT_COMPAT_SETTER   \
 337     wxDEPRECATED_FUTURE( void SetFamily(int family) ) \
 338         { SetFamily((wxFontFamily)family); } \
 339     wxDEPRECATED_FUTURE( void SetStyle(int style) ) \
 340         { SetStyle((wxFontStyle)style); } \
 341     wxDEPRECATED_FUTURE( void SetWeight(int weight) ) \
 342         { SetWeight((wxFontWeight)weight); } \
 343     wxDEPRECATED_FUTURE( void SetFamily(wxDeprecatedGUIConstants family) ) \
 344         { SetFamily((wxFontFamily)family); } \
 345     wxDEPRECATED_FUTURE( void SetStyle(wxDeprecatedGUIConstants style) ) \
 346         { SetStyle((wxFontStyle)style); } \
 347     wxDEPRECATED_FUTURE( void SetWeight(wxDeprecatedGUIConstants weight) ) \
 348         { SetWeight((wxFontWeight)weight); }
 349 #else
 350 #define wxDECLARE_FONT_COMPAT_SETTER  /*empty*/
 351 #endif
 352
 353 // this macro must be used in all derived wxFont classes declarations
 354 #define wxDECLARE_COMMON_FONT_METHODS() \
 355     wxDECLARE_FONT_COMPAT_SETTER \
 356  \
 357     /* functions for modifying font in place */ \
 358     wxFont& MakeBold(); \
 359     wxFont& MakeItalic(); \
 360     wxFont& MakeUnderlined(); \
 361     wxFont& MakeStrikethrough(); \
 362     wxFont& MakeLarger() { return Scale(1.2f); } \
 363     wxFont& MakeSmaller() { return Scale(1/1.2f); } \
 364     wxFont& Scale(float x); \
 365     /* functions for creating fonts based on this one */ \
 366     wxFont Bold() const; \
 367     wxFont Italic() const; \
 368     wxFont Underlined() const; \
 369     wxFont Strikethrough() const; \
 370     wxFont Larger() const { return Scaled(1.2f); } \
 371     wxFont Smaller() const { return Scaled(1/1.2f); } \
 372     wxFont Scaled(float x) const
 373
 374 // include the real class declaration
 375 #if defined(__WXMSW__)
 376     #include "wx/msw/font.h"
 377 #elif defined(__WXMOTIF__)
 378     #include "wx/motif/font.h"
 379 #elif defined(__WXGTK20__)
 380     #include "wx/gtk/font.h"
 381 #elif defined(__WXGTK__)
 382     #include "wx/gtk1/font.h"
 383 #elif defined(__WXX11__)
 384     #include "wx/x11/font.h"
 385 #elif defined(__WXDFB__)
 386     #include "wx/dfb/font.h"
 387 #elif defined(__WXMAC__)
 388     #include "wx/osx/font.h"
 389 #elif defined(__WXCOCOA__)
 390     #include "wx/cocoa/font.h"
 391 #elif defined(__WXPM__)
 392     #include "wx/os2/font.h"
 393 #endif
 394
 395 class WXDLLIMPEXP_CORE wxFontList: public wxGDIObjListBase
 396 {
 397 public:
 398     wxFont *FindOrCreateFont(int pointSize,
 399                              wxFontFamily family,
 400                              wxFontStyle style,
 401                              wxFontWeight weight,
 402                              bool underline = false,
 403                              const wxString& face = wxEmptyString,
 404                              wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 405
 406 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 407      wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
 408                               bool underline = false,
 409                               const wxString& face = wxEmptyString,
 410                               wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
 411         { return FindOrCreateFont(pointSize, (wxFontFamily)family, (wxFontStyle)style,
 412                                   (wxFontWeight)weight, underline, face, encoding); }
 413 #endif
 414
 415 #if WXWIN_COMPATIBILITY_2_6
 416     wxDEPRECATED( void AddFont(wxFont*) );
 417     wxDEPRECATED( void RemoveFont(wxFont*) );
 418 #endif
 419 };
 420
 421 extern WXDLLIMPEXP_DATA_CORE(wxFontList*)    wxTheFontList;
 422
 423
 424 // provide comparison operators to allow code such as
 425 //
 426 //      if ( font.GetStyle() == wxFONTSTYLE_SLANT )
 427 //
 428 // to compile without warnings which it would otherwise provoke from some
 429 // compilers as it compares elements of different enums
 430 #if FUTURE_WXWIN_COMPATIBILITY_3_0
 431
 432 // Unfortunately some compilers have ambiguity issues when enum comparisons are
 433 // overloaded so we have to disable the overloads in this case, see
 434 // wxCOMPILER_NO_OVERLOAD_ON_ENUM definition in wx/platform.h for more details.
 435 #ifndef wxCOMPILER_NO_OVERLOAD_ON_ENUM
 436
 437 inline bool operator==(wxFontFamily s, wxDeprecatedGUIConstants t)
 438 { return static_cast<int>(s) == static_cast<int>(t); }
 439 inline bool operator!=(wxFontFamily s, wxDeprecatedGUIConstants t)
 440 { return !(s == t); }
 441 inline bool operator==(wxFontStyle s, wxDeprecatedGUIConstants t)
 442 { return static_cast<int>(s) == static_cast<int>(t); }
 443 inline bool operator!=(wxFontStyle s, wxDeprecatedGUIConstants t)
 444 { return !(s == t); }
 445 inline bool operator==(wxFontWeight s, wxDeprecatedGUIConstants t)
 446 { return static_cast<int>(s) == static_cast<int>(t); }
 447 inline bool operator!=(wxFontWeight s, wxDeprecatedGUIConstants t)
 448 { return !(s == t); }
 449
 450 #endif // // wxCOMPILER_NO_OVERLOAD_ON_ENUM
 451
 452 #endif // FUTURE_WXWIN_COMPATIBILITY_3_0
 453
 454 #endif
 455     // _WX_FONT_H_BASE_