added a way to create fonts with specified pixel size

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@29356 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

docs/changes.txt

@@ -240,6 +240,7 @@ All (GUI):
 - smoother time estimation updates in wxProgressDialog (Christian Sturmlechner)
 - the XRC contrib library was moved to the core
 - wx(Choice/List/Note)book controls send CHANG(ED/ING) events in SetSelection
+- it is now possible to create a wxFont with given size in pixels (d2walter)
 
 Unix:
 

docs/latex/wx/font.tex

@@ -19,6 +19,23 @@ You can retrieve the current system font settings with \helpref{wxSystemSettings
 
 \wxheading{Constants}
 
+The possible values for the \arg{family} parameter of \helpref{wxFont
+constructor}{wxfontconstr} are (the old names are for compatibility only):
+
+\begin{verbatim}
+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
+};
+\end{verbatim}
+
 The font flags which can be used during the font creation are:
 
 \begin{verbatim}
@@ -128,23 +145,32 @@ wxSWISS\_FONT}
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 
+
 \membersection{wxFont::wxFont}\label{wxfontconstr}
 
 \func{}{wxFont}{\void}
 
 Default constructor.
 
-\func{}{wxFont}{\param{int}{ pointSize}, \param{int}{ family}, \param{int}{ style}, \param{int}{ weight},
+\func{}{wxFont}{\param{int}{ pointSize}, \param{wxFontFamily}{ family}, \param{int}{ style}, \param{int}{ weight},
  \param{const bool}{ underline = false}, \param{const wxString\& }{faceName = ""},
  \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
 
-Creates a font object (see \helpref{font encoding
+\func{}{wxFont}{\param{const wxSize\&}{ pixelSize}, \param{wxFontFamily}{ family}, \param{int}{ style}, \param{int}{ weight},
-overview}{wxfontencodingoverview} for the meaning of the last parameter).
+ \param{const bool}{ underline = false}, \param{const wxString\& }{faceName = ""},
+ \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
+
+Creates a font object with the specified attributes.
 
 \wxheading{Parameters}
 
 \docparam{pointSize}{Size in points.}
 
+\docparam{pixelSize}{Size in pixels: this is directly supported only under MSW
+currently where this constructor can be used directly, under other platforms a
+font with the closest size to the given one is found using binary search and
+the static \helpref{New}{wxfontnew} method must be used.}
+
 \docparam{family}{Font family, a generic way of referring to fonts without specifying actual facename. One of:
 
 \twocolwidtha{5cm}
@@ -179,7 +205,8 @@ default application encoding is the same as default system encoding.}
 \twocolitem{{\bf wxFONTENCODING\_KOI8}}{The standard Russian encoding for Internet.}
 \twocolitem{{\bf wxFONTENCODING\_CP1250...1252}}{Windows encodings similar to ISO8859 (but not identical).}
 \end{twocollist}
-If the specified encoding isn't available, no font is created.
+If the specified encoding isn't available, no font is created
+(see also \helpref{font encoding overview}{wxfontencodingoverview}).
 }
 
 \wxheading{Remarks}
@@ -190,6 +217,7 @@ Under Windows, only scalable TrueType fonts are used.
 See also \helpref{wxDC::SetFont}{wxdcsetfont}, \helpref{wxDC::DrawText}{wxdcdrawtext}
 and \helpref{wxDC::GetTextExtent}{wxdcgettextextent}.
 
+
 \membersection{wxFont::\destruct{wxFont}}
 
 \func{}{\destruct{wxFont}}{\void}
@@ -206,6 +234,7 @@ the application should try to clean up all fonts itself. This is because
 wxWidgets cannot know if a pointer to the font object is stored in an
 application data structure, and there is a risk of double deletion.
 
+
 \membersection{wxFont::IsFixedWidth}\label{wxfontisfixedwidth}
 
 \constfunc{bool}{IsFixedWidth}{\void}
@@ -213,6 +242,7 @@ application data structure, and there is a risk of double deletion.
 Returns {\tt true} if the font is a fixed width (or monospaced) font, 
 {\tt false} if it is a proportional one or font is invalid.
 
+
 \membersection{wxFont::GetDefaultEncoding}\label{wxfontgetdefaultencoding}
 
 \func{static wxFontEncoding}{GetDefaultEncoding}{\void}
@@ -224,6 +254,7 @@ Returns the current application's default encoding.
 \helpref{Font encoding overview}{wxfontencodingoverview}, 
 \helpref{SetDefaultEncoding}{wxfontsetdefaultencoding}
 
+
 \membersection{wxFont::GetFaceName}\label{wxfontgetfacename}
 
 \constfunc{wxString}{GetFaceName}{\void}
@@ -235,6 +266,7 @@ typeface information.
 
 \helpref{wxFont::SetFaceName}{wxfontsetfacename}
 
+
 \membersection{wxFont::GetFamily}\label{wxfontgetfamily}
 
 \constfunc{int}{GetFamily}{\void}
@@ -246,6 +278,7 @@ family identifiers.
 
 \helpref{wxFont::SetFamily}{wxfontsetfamily}
 
+
 \membersection{wxFont::GetNativeFontInfoDesc}\label{wxfontgetnativefontinfodesc}
 
 \constfunc{wxString}{GetNativeFontInfoDesc}{\void}
@@ -257,6 +290,7 @@ empty string if the font wasn't constructed using the native font description.
 
 \helpref{wxFont::SetNativeFontInfo}{wxfontsetnativefontinfo}
 
+
 \membersection{wxFont::GetPointSize}\label{wxfontgetpointsize}
 
 \constfunc{int}{GetPointSize}{\void}
@@ -267,6 +301,7 @@ Gets the point size.
 
 \helpref{wxFont::SetPointSize}{wxfontsetpointsize}
 
+
 \membersection{wxFont::GetStyle}\label{wxfontgetstyle}
 
 \constfunc{int}{GetStyle}{\void}
@@ -278,6 +313,7 @@ styles.
 
 \helpref{wxFont::SetStyle}{wxfontsetstyle}
 
+
 \membersection{wxFont::GetUnderlined}\label{wxfontgetunderlined}
 
 \constfunc{bool}{GetUnderlined}{\void}
@@ -288,6 +324,7 @@ Returns true if the font is underlined, false otherwise.
 
 \helpref{wxFont::SetUnderlined}{wxfontsetunderlined}
 
+
 \membersection{wxFont::GetWeight}\label{wxfontgetweight}
 
 \constfunc{int}{GetWeight}{\void}
@@ -299,12 +336,39 @@ weight identifiers.
 
 \helpref{wxFont::SetWeight}{wxfontsetweight}
 
+
+\membersection{wxFont::New}\label{wxfontnew}
+
+\func{static wxFont *}{New}{\param{int}{ pointSize}, \param{wxFontFamily}{ family}, \param{int}{ style}, \param{int}{ weight},
+ \param{const bool}{ underline = false}, \param{const wxString\& }{faceName = ""},
+ \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
+
+\func{static wxFont *}{New}{\param{int}{ pointSize}, \param{wxFontFamily}{ family}, 
+ \param{int}{ flags = \texttt{wxFONTFLAG\_DEFAULT}}, \param{const wxString\& }{faceName = ""},
+ \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
+
+\func{static wxFont *}{New}{\param{const wxSize\&}{ pixelSize}, \param{wxFontFamily}{ family}, \param{int}{ style}, \param{int}{ weight},
+ \param{const bool}{ underline = false}, \param{const wxString\& }{faceName = ""},
+ \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
+
+\func{static wxFont *}{New}{\param{const wxSize\&}{ pixelSize}, \param{wxFontFamily}{ family}, 
+ \param{int}{ flags = \texttt{wxFONTFLAG\_DEFAULT}}, \param{const wxString\& }{faceName = ""},
+ \param{wxFontEncoding }{encoding = wxFONTENCODING\_DEFAULT}}
+
+These functions take the same parameters as \helpref{wxFont
+constructor}{wxfontconstr} and return a new font object allocated on the heap.
+
+Using \texttt{New()} is currently the only way to directly create a font with
+the given size in pixels on platforms other than wxMSW.
+
+
 \membersection{wxFont::Ok}\label{wxfontok}
 
 \constfunc{bool}{Ok}{\void}
 
 Returns {\tt true} if this object is a valid font, {\tt false} otherwise.
 
+
 \membersection{wxFont::SetDefaultEncoding}\label{wxfontsetdefaultencoding}
 
 \func{static void}{SetDefaultEncoding}{\param{wxFontEncoding }{encoding}}
@@ -316,6 +380,7 @@ Sets the default font encoding.
 \helpref{Font encoding overview}{wxfontencodingoverview}, 
 \helpref{GetDefaultEncoding}{wxfontgetdefaultencoding}
 
+
 \membersection{wxFont::SetFaceName}\label{wxfontsetfacename}
 
 \func{void}{SetFaceName}{\param{const wxString\& }{faceName}}
@@ -337,6 +402,7 @@ and then for a font belonging to the same family.
 
 \helpref{wxFont::GetFaceName}{wxfontgetfacename}, \helpref{wxFont::SetFamily}{wxfontsetfamily}
 
+
 \membersection{wxFont::SetFamily}\label{wxfontsetfamily}
 
 \func{void}{SetFamily}{\param{int}{ family}}
@@ -361,6 +427,7 @@ Sets the font family.
 
 \helpref{wxFont::GetFamily}{wxfontgetfamily}, \helpref{wxFont::SetFaceName}{wxfontsetfacename}
 
+
 \membersection{wxFont::SetNativeFontInfo}\label{wxfontsetnativefontinfo}
 
 \func{void}{SetNativeFontInfo}{\param{const wxString\& }{info}}
@@ -370,6 +437,7 @@ which must have been previously returned by
 \helpref{GetNativeFontInfoDesc}{wxfontgetnativefontinfodesc}. If the string is
 invalid, font is unchanged.
 
+
 \membersection{wxFont::SetPointSize}\label{wxfontsetpointsize}
 
 \func{void}{SetPointSize}{\param{int}{ pointSize}}
@@ -384,6 +452,7 @@ Sets the point size.
 
 \helpref{wxFont::GetPointSize}{wxfontgetpointsize}
 
+
 \membersection{wxFont::SetStyle}\label{wxfontsetstyle}
 
 \func{void}{SetStyle}{\param{int}{ style}}
@@ -398,6 +467,7 @@ Sets the font style.
 
 \helpref{wxFont::GetStyle}{wxfontgetstyle}
 
+
 \membersection{wxFont::SetUnderlined}\label{wxfontsetunderlined}
 
 \func{void}{SetUnderlined}{\param{const bool}{ underlined}}
@@ -412,6 +482,7 @@ Sets underlining.
 
 \helpref{wxFont::GetUnderlined}{wxfontgetunderlined}
 
+
 \membersection{wxFont::SetWeight}\label{wxfontsetweight}
 
 \func{void}{SetWeight}{\param{int}{ weight}}
@@ -426,6 +497,7 @@ Sets the font weight.
 
 \helpref{wxFont::GetWeight}{wxfontgetweight}
 
+
 \membersection{wxFont::operator $=$}\label{wxfontassignment}
 
 \func{wxFont\&}{operator $=$}{\param{const wxFont\& }{font}}
@@ -433,6 +505,7 @@ Sets the font weight.
 Assignment operator, using reference counting. Returns a reference
 to `this'.
 
+
 \membersection{wxFont::operator $==$}\label{wxfontequals}
 
 \func{bool}{operator $==$}{\param{const wxFont\& }{font}}
@@ -442,6 +515,7 @@ to the same underlying font data. It does not compare each attribute,
 so two independently-created fonts using the same parameters will
 fail the test.
 
+
 \membersection{wxFont::operator $!=$}\label{wxfontnotequals}
 
 \func{bool}{operator $!=$}{\param{const wxFont\& }{font}}

include/wx/font.h

@@ -135,6 +135,24 @@ public:
                        const wxString& face = wxEmptyString,
                        wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 
+    // from the font components
+    static wxFont *New(
+        const wxSize& pixelSize,    // size of the font in pixels
+        int family,                 // see wxFontFamily enum
+        int style,                  // see wxFontStyle enum
+        int weight,                 // see wxFontWeight enum
+        bool underlined = FALSE,    // not underlined by default
+        const wxString& face = wxEmptyString,              // facename
+        wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
+
+    // from the font components but using the font flags instead of separate
+    // parameters for each flag
+    static wxFont *New(const wxSize& pixelSize,
+                       wxFontFamily family,
+                       int flags = wxFONTFLAG_DEFAULT,
+                       const wxString& face = wxEmptyString,
+                       wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
+
     // from the (opaque) native font description object
     static wxFont *New(const wxNativeFontInfo& nativeFontDesc);
 
@@ -150,6 +168,8 @@ public:
 
     // accessors: get the font characteristics
     virtual int GetPointSize() const = 0;
+    virtual wxSize GetPixelSize() const;
+    virtual bool IsUsingSizeInPixels() const;
     virtual int GetFamily() const = 0;
     virtual int GetStyle() const = 0;
     virtual int GetWeight() const = 0;
@@ -165,6 +185,7 @@ public:
 
     // change the font characteristics
     virtual void SetPointSize( int pointSize ) = 0;
+    virtual void SetPixelSize( const wxSize& pixelSize );
     virtual void SetFamily( int family ) = 0;
     virtual void SetStyle( int style ) = 0;
     virtual void SetWeight( int weight ) = 0;

include/wx/fontutil.h

@@ -162,7 +162,14 @@ public:
         SetStyle((wxFontStyle)font.GetStyle());
         SetWeight((wxFontWeight)font.GetWeight());
         SetUnderlined(font.GetUnderlined());
+#if defined(__WXMSW__)
+        if ( font.IsUsingSizeInPixels() )
+            SetPixelSize(font.GetPixelSize());
+        else
         SetPointSize(font.GetPointSize());
+#else
+        SetPointSize(font.GetPointSize());
+#endif
 
         // set the family/facename
         SetFamily((wxFontFamily)font.GetFamily());
@@ -179,6 +186,7 @@ public:
 
     // accessors and modifiers for the font elements
     int GetPointSize() const;
+    wxSize GetPixelSize() const;
     wxFontStyle GetStyle() const;
     wxFontWeight GetWeight() const;
     bool GetUnderlined() const;
@@ -187,6 +195,7 @@ public:
     wxFontEncoding GetEncoding() const;
 
     void SetPointSize(int pointsize);
+    void SetPixelSize(const wxSize& pixelSize);
     void SetStyle(wxFontStyle style);
     void SetWeight(wxFontWeight weight);
     void SetUnderlined(bool underlined);

include/wx/msw/font.h

@@ -37,7 +37,22 @@ public:
     {
         Init();
 
-        (void)Create(size, family, style, weight, underlined, face, encoding);
+        (void)Create(size, wxSize(0, 0), FALSE, family, style, weight,
+                     underlined, face, encoding);
+    }
+
+    wxFont(const wxSize& pixelSize,
+           int family,
+           int style,
+           int weight,
+           bool underlined = false,
+           const wxString& face = wxEmptyString,
+           wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
+    {
+        Init();
+
+        (void)Create(0, pixelSize, TRUE, family, style, weight, underlined,
+                     face, encoding);
     }
 
     wxFont(const wxNativeFontInfo& info, WXHFONT hFont = 0)
@@ -50,6 +65,8 @@ public:
     wxFont(const wxString& fontDesc);
 
     bool Create(int size,
+                const wxSize& pixelSize,
+                bool sizeUsingPixels,
                 int family,
                 int style,
                 int weight,
@@ -66,6 +83,8 @@ public:
 
     // implement base class pure virtuals
     virtual int GetPointSize() const;
+    virtual wxSize GetPixelSize() const;
+    virtual bool IsUsingSizeInPixels() const;
     virtual int GetFamily() const;
     virtual int GetStyle() const;
     virtual int GetWeight() const;
@@ -75,6 +94,7 @@ public:
     virtual const wxNativeFontInfo *GetNativeFontInfo() const;
 
     virtual void SetPointSize(int pointSize);
+    virtual void SetPixelSize(const wxSize& pixelSize);
     virtual void SetFamily(int family);
     virtual void SetStyle(int style);
     virtual void SetWeight(int weight);

src/common/fontcmn.cpp

@@ -49,6 +49,61 @@
 // implementation
 // ============================================================================
 
+// ----------------------------------------------------------------------------
+// helper functions
+// ----------------------------------------------------------------------------
+
+static void AdjustFontSize(wxFont font, wxDC& dc, const wxSize& pixelSize)
+{
+    int currentSize = font.GetPointSize();
+    int largestGood;
+    int smallestBad;
+
+    bool initialGoodFound = false;
+    bool initialBadFound = false;
+
+    while (currentSize > 0)
+    {
+        dc.SetFont(font);
+
+        // if currentSize (in points) results in a font that is smaller
+        // than required by pixelSize it is considered a good size
+        if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
+                (!pixelSize.GetWidth() ||
+                 dc.GetCharWidth() <= pixelSize.GetWidth()))
+        {
+            largestGood = currentSize;
+            initialGoodFound = true;
+        }
+        else
+        {
+            smallestBad = currentSize;
+            initialBadFound = true;
+        }
+        if (!initialGoodFound)
+        {
+            currentSize /= 2;
+        }
+        else if (!initialBadFound)
+        {
+            currentSize *= 2;
+        }
+        else
+        {
+            int distance = smallestBad - largestGood;
+            if (distance == 1)
+                break;
+
+            currentSize = largestGood + distance / 2;
+        }
+
+        font.SetPointSize(currentSize);
+    }
+
+    if (currentSize != largestGood)
+        font.SetPointSize(largestGood);
+}
+
 // ----------------------------------------------------------------------------
 // wxFontBase
 // ----------------------------------------------------------------------------
@@ -83,6 +138,29 @@ wxFont *wxFontBase::New(int size,
     return new wxFont(size, family, style, weight, underlined, face, encoding);
 }
 
+static inline int flags2Style(int flags)
+{
+    return flags & wxFONTFLAG_ITALIC
+                    ? wxFONTSTYLE_ITALIC
+                    : flags & wxFONTFLAG_SLANT
+                        ? wxFONTSTYLE_SLANT
+                        : wxFONTSTYLE_NORMAL;
+}
+
+static inline int flags2Weight(int flags)
+{
+    return flags & wxFONTFLAG_LIGHT
+                    ? wxFONTWEIGHT_LIGHT
+                    : flags & wxFONTFLAG_BOLD
+                        ? wxFONTWEIGHT_BOLD
+                        : wxFONTWEIGHT_NORMAL;
+}
+
+static inline bool flags2Underlined(int flags)
+{
+    return (flags & wxFONTFLAG_UNDERLINED) != 0;
+}
+
 /* static */
 wxFont *wxFontBase::New(int pointSize,
                         wxFontFamily family,
@@ -90,24 +168,57 @@ wxFont *wxFontBase::New(int pointSize,
                         const wxString& face,
                         wxFontEncoding encoding)
 {
-    return New
+    return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
-           (
+               flags2Underlined(flags), face, encoding);
-                pointSize,
+}
-                family,
+
-                flags & wxFONTFLAG_ITALIC
+/* static */
-                    ? wxFONTSTYLE_ITALIC
+wxFont *wxFontBase::New(const wxSize& pixelSize,
-                    : flags & wxFONTFLAG_SLANT
+                        int family,
-                        ? wxFONTSTYLE_SLANT
+                        int style,
-                        : wxFONTSTYLE_NORMAL,
+                        int weight,
-                flags & wxFONTFLAG_LIGHT
+                        bool underlined,
-                    ? wxFONTWEIGHT_LIGHT
+                        const wxString& face,
-                    : flags & wxFONTFLAG_BOLD
+                        wxFontEncoding encoding)
-                        ? wxFONTWEIGHT_BOLD
+{
-                        : wxFONTWEIGHT_NORMAL,
+#if defined(__WXMSW__)
-                (flags & wxFONTFLAG_UNDERLINED) != 0,
+    return new wxFont(pixelSize, family, style, weight, underlined,
-                face,
+                      face, encoding);
-                encoding
+#else
-           );
+    wxFont * ret = New(10, family, style, weight, underlined, face, encoding);
+    wxScreenDC dc;
+    ret->AdjustFontSize(*(wxFont *)this, dc, pixelSize);
+    return ret;
+#endif
+}
+
+/* static */
+wxFont *wxFontBase::New(const wxSize& pixelSize,
+                        wxFontFamily family,
+                        int flags,
+                        const wxString& face,
+                        wxFontEncoding encoding)
+{
+    return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
+               flags2Underlined(flags), face, encoding);
+}
+
+wxSize wxFontBase::GetPixelSize() const
+{
+    wxScreenDC dc;
+    dc.SetFont(*(wxFont *)this);
+    return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
+}
+
+bool wxFontBase::IsUsingSizeInPixels() const
+{
+    return false;
+}
+
+void wxFontBase::SetPixelSize( const wxSize& pixelSize )
+{
+    wxScreenDC dc;
+    AdjustFontSize(*(wxFont *)this, dc, pixelSize);
 }
 
 /* static */

src/msw/font.cpp

@@ -108,11 +108,14 @@ public:
     // constructors
     wxFontRefData()
     {
-        Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
+        Init(-1, wxSize(0, 0), FALSE, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,
-             false, wxEmptyString, wxFONTENCODING_DEFAULT);
+             wxFONTWEIGHT_NORMAL, FALSE, wxEmptyString,
+             wxFONTENCODING_DEFAULT);
     }
 
     wxFontRefData(int size,
+                  const wxSize& pixelSize,
+                  bool sizeUsingPixels,
                   int family,
                   int style,
                   int weight,
@@ -120,7 +123,8 @@ public:
                   const wxString& faceName,
                   wxFontEncoding encoding)
     {
-        Init(size, family, style, weight, underlined, faceName, encoding);
+        Init(size, pixelSize, sizeUsingPixels, family, style, weight,
+             underlined, faceName, encoding);
     }
 
     wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0)
@@ -136,7 +140,8 @@ public:
         }
         else
         {
-            Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
+            Init(data.m_pointSize, data.m_pixelSize, data.m_sizeUsingPixels,
+                 data.m_family, data.m_style, data.m_weight,
                  data.m_underlined, data.m_faceName, data.m_encoding);
         }
     }
@@ -155,6 +160,17 @@ public:
                                   : m_pointSize;
     }
 
+    wxSize GetPixelSize() const
+    {
+        return m_nativeFontInfoOk ? m_nativeFontInfo.GetPixelSize()
+                                  : m_pixelSize;
+    }
+    
+    bool IsUsingSizeInPixels() const
+    {
+        return m_nativeFontInfoOk ? TRUE : m_sizeUsingPixels;
+    }
+
     int GetFamily() const
     {
         return m_family;
@@ -201,9 +217,27 @@ public:
     void SetPointSize(int pointSize)
     {
         if ( m_nativeFontInfoOk )
+        {
             m_nativeFontInfo.SetPointSize(pointSize);
+        }
         else
+        {
             m_pointSize = pointSize;
+            m_sizeUsingPixels = FALSE;
+        }
+    }
+
+    void SetPixelSize(const wxSize& pixelSize)
+    {
+        if ( m_nativeFontInfoOk )
+        {
+            m_nativeFontInfo.SetPixelSize(pixelSize);
+        }
+        else
+        {
+            m_pixelSize = pixelSize;
+            m_sizeUsingPixels = TRUE;
+        }
     }
 
     void SetFamily(int family)
@@ -260,6 +294,8 @@ public:
 protected:
     // common part of all ctors
     void Init(int size,
+              const wxSize& pixelSize,
+              bool sizeUsingPixels,
               int family,
               int style,
               int weight,
@@ -271,6 +307,8 @@ protected:
 
     // font characterstics
     int           m_pointSize;
+    wxSize        m_pixelSize;
+    bool          m_sizeUsingPixels;
     int           m_family;
     int           m_style;
     int           m_weight;
@@ -295,6 +333,8 @@ protected:
 // ----------------------------------------------------------------------------
 
 void wxFontRefData::Init(int pointSize,
+                         const wxSize& pixelSize,
+                         bool sizeUsingPixels,
                          int family,
                          int style,
                          int weight,
@@ -304,6 +344,8 @@ void wxFontRefData::Init(int pointSize,
 {
     m_style = style;
     m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize;
+    m_pixelSize = pixelSize;
+    m_sizeUsingPixels = sizeUsingPixels;
     m_family = family;
     m_style = style;
     m_weight = weight;
@@ -388,6 +430,14 @@ int wxNativeFontInfo::GetPointSize() const
     return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5);
 }
 
+wxSize wxNativeFontInfo::GetPixelSize() const
+{
+    wxSize ret;
+    ret.SetHeight(lf.lfHeight);
+    ret.SetWidth(lf.lfWidth);
+    return ret;
+}
+
 wxFontStyle wxNativeFontInfo::GetStyle() const
 {
     return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL;
@@ -468,6 +518,13 @@ void wxNativeFontInfo::SetPointSize(int pointsize)
 #endif // wxFONT_SIZE_COMPATIBILITY/!wxFONT_SIZE_COMPATIBILITY
 }
 
+void wxNativeFontInfo::SetPixelSize(const wxSize& pixelSize)
+{
+    lf.lfHeight = pixelSize.GetHeight();
+    lf.lfWidth = pixelSize.GetWidth();
+}
+
+
 void wxNativeFontInfo::SetStyle(wxFontStyle style)
 {
     switch ( style )
@@ -731,6 +788,8 @@ wxFont::wxFont(const wxString& fontdesc)
  * in wxDC::SetFont, when information is available about scaling etc.
  */
 bool wxFont::Create(int pointSize,
+                    const wxSize& pixelSize,
+                    bool sizeUsingPixels,
                     int family,
                     int style,
                     int weight,
@@ -747,7 +806,8 @@ bool wxFont::Create(int pointSize,
         pointSize = wxNORMAL_FONT->GetPointSize();
     }
 
-    m_refData = new wxFontRefData(pointSize, family, style, weight,
+    m_refData = new wxFontRefData(pointSize, pixelSize, sizeUsingPixels,
+                                  family, style, weight,
                                   underlined, faceName, encoding);
 
     RealizeResource();
@@ -830,6 +890,15 @@ void wxFont::SetPointSize(int pointSize)
     RealizeResource();
 }
 
+void wxFont::SetPixelSize(const wxSize& pixelSize)
+{
+    Unshare();
+
+    M_FONTDATA->SetPixelSize(pixelSize);
+
+    RealizeResource();
+}
+
 void wxFont::SetFamily(int family)
 {
     Unshare();
@@ -906,6 +975,18 @@ int wxFont::GetPointSize() const
     return M_FONTDATA->GetPointSize();
 }
 
+wxSize wxFont::GetPixelSize() const
+{
+    return M_FONTDATA->GetPixelSize();
+}
+
+bool wxFont::IsUsingSizeInPixels() const
+{
+    wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
+
+    return M_FONTDATA->IsUsingSizeInPixels();
+}
+
 int wxFont::GetFamily() const
 {
     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );