src/msw/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        font.cpp
   3 // Purpose:     wxFont class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:       wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "font.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include <stdio.h>
  33     #include "wx/setup.h"
  34     #include "wx/list.h"
  35     #include "wx/utils.h"
  36     #include "wx/app.h"
  37     #include "wx/font.h"
  38 #endif // WX_PRECOMP
  39
  40 #include "wx/msw/private.h"
  41
  42 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
  43
  44 // ----------------------------------------------------------------------------
  45 // wxFontRefData - the internal description of the font
  46 // ----------------------------------------------------------------------------
  47
  48 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
  49 {
  50 friend class WXDLLEXPORT wxFont;
  51
  52 public:
  53     wxFontRefData()
  54     {
  55         Init(12, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
  56              "", wxFONTENCODING_DEFAULT);
  57     }
  58
  59     wxFontRefData(const wxFontRefData& data)
  60     {
  61         Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
  62              data.m_underlined, data.m_faceName, data.m_encoding);
  63
  64         m_fontId = data.m_fontId;
  65     }
  66
  67     wxFontRefData(int size,
  68                   int family,
  69                   int style,
  70                   int weight,
  71                   bool underlined,
  72                   const wxString& faceName,
  73                   wxFontEncoding encoding)
  74     {
  75         Init(size, family, style, weight, underlined, faceName, encoding);
  76     }
  77
  78     virtual ~wxFontRefData();
  79
  80 protected:
  81     // common part of all ctors
  82     void Init(int size,
  83               int family,
  84               int style,
  85               int weight,
  86               bool underlined,
  87               const wxString& faceName,
  88               wxFontEncoding encoding);
  89
  90     // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE
  91     // DELETED by destructor
  92     bool          m_temporary;
  93
  94     int           m_fontId;
  95
  96     // font characterstics
  97     int           m_pointSize;
  98     int           m_family;
  99     int           m_style;
 100     int           m_weight;
 101     bool          m_underlined;
 102     wxString      m_faceName;
 103     wxFontEncoding m_encoding;
 104
 105     // Windows font handle
 106     WXHFONT       m_hFont;
 107 };
 108
 109 // ============================================================================
 110 // implementation
 111 // ============================================================================
 112
 113 // ----------------------------------------------------------------------------
 114 // wxFontRefData
 115 // ----------------------------------------------------------------------------
 116
 117 void wxFontRefData::Init(int pointSize,
 118                          int family,
 119                          int style,
 120                          int weight,
 121                          bool underlined,
 122                          const wxString& faceName,
 123                          wxFontEncoding encoding)
 124 {
 125     m_style = style;
 126     m_pointSize = pointSize;
 127     m_family = family;
 128     m_style = style;
 129     m_weight = weight;
 130     m_underlined = underlined;
 131     m_faceName = faceName;
 132     m_encoding = encoding;
 133
 134     m_fontId = 0;
 135     m_temporary = FALSE;
 136
 137     m_hFont = 0;
 138 }
 139
 140 wxFontRefData::~wxFontRefData()
 141 {
 142     if ( m_hFont )
 143     {
 144         if ( !::DeleteObject((HFONT) m_hFont) )
 145         {
 146             wxLogLastError("DeleteObject(font)");
 147         }
 148     }
 149 }
 150
 151 // ----------------------------------------------------------------------------
 152 // wxFont
 153 // ----------------------------------------------------------------------------
 154
 155 void wxFont::Init()
 156 {
 157     if ( wxTheFontList )
 158         wxTheFontList->Append(this);
 159 }
 160
 161 /* Constructor for a font. Note that the real construction is done
 162  * in wxDC::SetFont, when information is available about scaling etc.
 163  */
 164 bool wxFont::Create(int pointSize,
 165                     int family,
 166                     int style,
 167                     int weight,
 168                     bool underlined,
 169                     const wxString& faceName,
 170                     wxFontEncoding encoding)
 171 {
 172     UnRef();
 173     m_refData = new wxFontRefData(pointSize, family, style, weight,
 174                                   underlined, faceName, encoding);
 175
 176     RealizeResource();
 177
 178     return TRUE;
 179 }
 180
 181 wxFont::~wxFont()
 182 {
 183     if ( wxTheFontList )
 184         wxTheFontList->DeleteObject(this);
 185 }
 186
 187 // ----------------------------------------------------------------------------
 188 // real implementation
 189 // ----------------------------------------------------------------------------
 190
 191 bool wxFont::RealizeResource()
 192 {
 193     if ( GetResourceHandle() )
 194     {
 195         // VZ: the old code returned FALSE in this case, but it doesn't seem
 196         //     to make sense because the font _was_ created
 197         return TRUE;
 198     }
 199
 200     LOGFONT lf;
 201     wxFillLogFont(&lf, this);
 202     M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&lf);
 203     M_FONTDATA->m_faceName = lf.lfFaceName;
 204     if ( !M_FONTDATA->m_hFont )
 205     {
 206         wxLogLastError("CreateFont");
 207
 208         return FALSE;
 209     }
 210
 211     return TRUE;
 212 }
 213
 214 bool wxFont::FreeResource(bool force)
 215 {
 216     if ( GetResourceHandle() )
 217     {
 218         if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) )
 219         {
 220             wxLogLastError("DeleteObject(font)");
 221         }
 222
 223         M_FONTDATA->m_hFont = 0;
 224
 225         return TRUE;
 226     }
 227     return FALSE;
 228 }
 229
 230 WXHANDLE wxFont::GetResourceHandle()
 231 {
 232     if ( !M_FONTDATA )
 233         return 0;
 234     else
 235         return (WXHANDLE)M_FONTDATA->m_hFont;
 236 }
 237
 238 bool wxFont::IsFree() const
 239 {
 240     return (M_FONTDATA && (M_FONTDATA->m_hFont == 0));
 241 }
 242
 243 void wxFont::Unshare()
 244 {
 245     // Don't change shared data
 246     if ( !m_refData )
 247     {
 248         m_refData = new wxFontRefData();
 249     }
 250     else
 251     {
 252         wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
 253         UnRef();
 254         m_refData = ref;
 255     }
 256 }
 257
 258 // ----------------------------------------------------------------------------
 259 // change font attribute: we recreate font when doing it
 260 // ----------------------------------------------------------------------------
 261
 262 void wxFont::SetPointSize(int pointSize)
 263 {
 264     Unshare();
 265
 266     M_FONTDATA->m_pointSize = pointSize;
 267
 268     RealizeResource();
 269 }
 270
 271 void wxFont::SetFamily(int family)
 272 {
 273     Unshare();
 274
 275     M_FONTDATA->m_family = family;
 276
 277     RealizeResource();
 278 }
 279
 280 void wxFont::SetStyle(int style)
 281 {
 282     Unshare();
 283
 284     M_FONTDATA->m_style = style;
 285
 286     RealizeResource();
 287 }
 288
 289 void wxFont::SetWeight(int weight)
 290 {
 291     Unshare();
 292
 293     M_FONTDATA->m_weight = weight;
 294
 295     RealizeResource();
 296 }
 297
 298 void wxFont::SetFaceName(const wxString& faceName)
 299 {
 300     Unshare();
 301
 302     M_FONTDATA->m_faceName = faceName;
 303
 304     RealizeResource();
 305 }
 306
 307 void wxFont::SetUnderlined(bool underlined)
 308 {
 309     Unshare();
 310
 311     M_FONTDATA->m_underlined = underlined;
 312
 313     RealizeResource();
 314 }
 315
 316 void wxFont::SetEncoding(wxFontEncoding encoding)
 317 {
 318     Unshare();
 319
 320     M_FONTDATA->m_encoding = encoding;
 321
 322     RealizeResource();
 323 }
 324
 325 // ----------------------------------------------------------------------------
 326 // accessors
 327 // ----------------------------------------------------------------------------
 328
 329 int wxFont::GetPointSize() const
 330 {
 331     return M_FONTDATA->m_pointSize;
 332 }
 333
 334 int wxFont::GetFamily() const
 335 {
 336     return M_FONTDATA->m_family;
 337 }
 338
 339 int wxFont::GetFontId() const
 340 {
 341     return M_FONTDATA->m_fontId;
 342 }
 343
 344 int wxFont::GetStyle() const
 345 {
 346     return M_FONTDATA->m_style;
 347 }
 348
 349 int wxFont::GetWeight() const
 350 {
 351     return M_FONTDATA->m_weight;
 352 }
 353
 354 bool wxFont::GetUnderlined() const
 355 {
 356     return M_FONTDATA->m_underlined;
 357 }
 358
 359 wxString wxFont::GetFaceName() const
 360 {
 361     wxString str;
 362     if ( M_FONTDATA )
 363         str = M_FONTDATA->m_faceName;
 364     return str;
 365 }
 366
 367 wxFontEncoding wxFont::GetEncoding() const
 368 {
 369     return M_FONTDATA->m_encoding;
 370 }
 371