X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ce3b4b90c51756092f1db8e5d87d07adb0a96e73..4081eb6fe2de5eed5716459d09c8f4bed8eda92d:/src/msw/pen.cpp

diff --git a/src/msw/pen.cpp b/src/msw/pen.cpp
index 7c22229a90..ae66559cec 100644
--- a/src/msw/pen.cpp
+++ b/src/msw/pen.cpp
@@ -2,13 +2,21 @@
 // Name:        src/msw/pen.cpp
 // Purpose:     wxPen
 // Author:      Julian Smart
-// Modified by:
+// Modified by: Vadim Zeitlin: refactored wxPen code to wxPenRefData
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
@@ -25,17 +33,27 @@
 
 #include "wx/msw/private.h"
 
-typedef WXDWORD wxMSWDash;
+#define M_PENDATA ((wxPenRefData*)m_refData)
 
-static int wx2msPenStyle(int wx_style);
+// Win32 has ExtCreatePen() but WinCE doesn't
+#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+    #define wxHAVE_EXT_CREATE_PEN
+#endif
 
-#define M_PENDATA ((wxPenRefData*)m_refData)
+// ----------------------------------------------------------------------------
+// wxPenRefData: contains information about an HPEN and its handle
+// ----------------------------------------------------------------------------
 
 class WXDLLEXPORT wxPenRefData : public wxGDIRefData
 {
 public:
+    // ctors and dtor
+    // --------------
+
     wxPenRefData();
     wxPenRefData(const wxPenRefData& data);
+    wxPenRefData(const wxColour& col, int width, wxPenStyle style);
+    wxPenRefData(const wxBitmap& stipple, int width);
     virtual ~wxPenRefData();
 
     bool operator==(const wxPenRefData& data) const
@@ -46,34 +64,103 @@ public:
                m_join == data.m_join &&
                m_cap == data.m_cap &&
                m_colour == data.m_colour &&
-               (m_style != wxSTIPPLE || m_stipple.IsSameAs(data.m_stipple)) &&
-               (m_style != wxUSER_DASH ||
+               (m_style != wxPENSTYLE_STIPPLE || m_stipple.IsSameAs(data.m_stipple)) &&
+               (m_style != wxPENSTYLE_USER_DASH ||
                 (m_nbDash == data.m_nbDash &&
                     memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
     }
 
+
+    // accessors and setters
+    // ---------------------
+
+    wxColour& GetColour() const { return wx_const_cast(wxColour&, m_colour); }
+    int GetWidth() const { return m_width; }
+    wxPenStyle GetStyle() const { return m_style; }
+    wxPenJoin GetJoin() const { return m_join; }
+    wxPenCap GetCap() const { return m_cap; }
+    wxDash* GetDash() const { return m_dash; }
+    int GetDashCount() const { return m_nbDash; }
+    wxBitmap* GetStipple() const { return wx_const_cast(wxBitmap *, &m_stipple); }
+
+    void SetColour(const wxColour& col) { Free(); m_colour = col; }
+    void SetWidth(int width) { Free(); m_width = width; }
+    void SetStyle(wxPenStyle style) { Free(); m_style = style; }
+    void SetStipple(const wxBitmap& stipple)
+    {
+        Free();
+
+        m_style = wxPENSTYLE_STIPPLE;
+        m_stipple = stipple;
+    }
+
+    void SetDashes(int nb_dashes, const wxDash *dash)
+    {
+        Free();
+
+        m_nbDash = nb_dashes;
+        m_dash = wx_const_cast(wxDash *, dash);
+    }
+
+    void SetJoin(wxPenJoin join) { Free(); m_join = join; }
+    void SetCap(wxPenCap cap) { Free(); m_cap = cap; }
+
+
+    // HPEN management
+    // ---------------
+
+    // create the HPEN if we don't have it yet
+    bool Alloc();
+
+    // get the HPEN creating it on demand
+    WXHPEN GetHPEN() const;
+
+    // return true if we have a valid HPEN
+    bool HasHPEN() const { return m_hPen != 0; }
+
+    // return true if we had a valid handle before, false otherwise
+    bool Free();
+
+private:
+    // initialize the fields which have reasonable default values
+    //
+    // doesn't initialize m_width and m_style which must be initialize in ctor
+    void Init()
+    {
+        m_join = wxJOIN_ROUND;
+        m_cap = wxCAP_ROUND;
+        m_nbDash = 0;
+        m_dash = NULL;
+        m_hPen = 0;
+    }
+
     int           m_width;
-    int           m_style;
-    int           m_join;
-    int           m_cap;
+    wxPenStyle    m_style;
+    wxPenJoin     m_join;
+    wxPenCap      m_cap;
     wxBitmap      m_stipple;
     int           m_nbDash;
     wxDash *      m_dash;
     wxColour      m_colour;
-    WXHPEN        m_hPen;
+    HPEN          m_hPen;
 
     DECLARE_NO_ASSIGN_CLASS(wxPenRefData)
 };
 
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxPenRefData ctors/dtor
+// ----------------------------------------------------------------------------
+
 wxPenRefData::wxPenRefData()
 {
-  m_style = wxSOLID;
-  m_width = 1;
-  m_join = wxJOIN_ROUND ;
-  m_cap = wxCAP_ROUND ;
-  m_nbDash = 0 ;
-  m_dash = (wxDash*)NULL;
-  m_hPen = 0;
+    Init();
+
+    m_style = wxPENSTYLE_SOLID;
+    m_width = 1;
 }
 
 wxPenRefData::wxPenRefData(const wxPenRefData& data)
@@ -89,396 +176,430 @@ wxPenRefData::wxPenRefData(const wxPenRefData& data)
     m_hPen = 0;
 }
 
-wxPenRefData::~wxPenRefData()
+wxPenRefData::wxPenRefData(const wxColour& col, int width, wxPenStyle style)
 {
-    if ( m_hPen )
-        ::DeleteObject((HPEN) m_hPen);
-}
+    Init();
 
-// Pens
+    m_style = style;
+    m_width = width;
 
-IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
+    m_colour = col;
+}
 
-wxPen::wxPen()
+wxPenRefData::wxPenRefData(const wxBitmap& stipple, int width)
 {
+    Init();
+
+    m_style = wxPENSTYLE_STIPPLE;
+    m_width = width;
+
+    m_stipple = stipple;
 }
 
-wxPen::~wxPen()
+wxPenRefData::~wxPenRefData()
 {
+    if ( m_hPen )
+        ::DeleteObject(m_hPen);
 }
 
-// Should implement Create
-wxPen::wxPen(const wxColour& col, int Width, int Style)
+// ----------------------------------------------------------------------------
+// wxPenRefData HPEN management
+// ----------------------------------------------------------------------------
+
+static int ConvertPenStyle(wxPenStyle style)
 {
-  m_refData = new wxPenRefData;
+    switch ( style )
+    {
+        case wxPENSTYLE_SHORT_DASH:
+        case wxPENSTYLE_LONG_DASH:
+            return PS_DASH;
+
+        case wxPENSTYLE_TRANSPARENT:
+            return PS_NULL;
+
+        default:
+            wxFAIL_MSG( _T("unknown pen style") );
+            // fall through
+
+#ifdef wxHAVE_EXT_CREATE_PEN
+        case wxPENSTYLE_DOT:
+            return PS_DOT;
+
+        case wxPENSTYLE_DOT_DASH:
+            return PS_DASHDOT;
 
-  M_PENDATA->m_colour = col;
-//  M_PENDATA->m_stipple = NULL;
-  M_PENDATA->m_width = Width;
-  M_PENDATA->m_style = Style;
-  M_PENDATA->m_join = wxJOIN_ROUND ;
-  M_PENDATA->m_cap = wxCAP_ROUND ;
-  M_PENDATA->m_nbDash = 0 ;
-  M_PENDATA->m_dash = (wxDash*)NULL;
-  M_PENDATA->m_hPen = 0 ;
+        case wxPENSTYLE_USER_DASH:
+            return PS_USERSTYLE;
 
-  RealizeResource();
+        case wxPENSTYLE_STIPPLE:
+        case wxPENSTYLE_BDIAGONAL_HATCH:
+        case wxPENSTYLE_CROSSDIAG_HATCH:
+        case wxPENSTYLE_FDIAGONAL_HATCH:
+        case wxPENSTYLE_CROSS_HATCH:
+        case wxPENSTYLE_HORIZONTAL_HATCH:
+        case wxPENSTYLE_VERTICAL_HATCH:
+        case wxPENSTYLE_SOLID:
+#endif // wxHAVE_EXT_CREATE_PEN
+
+            return PS_SOLID;
+    }
 }
 
-wxPen::wxPen(const wxBitmap& stipple, int Width)
+#ifdef wxHAVE_EXT_CREATE_PEN
+
+static int ConvertJoinStyle(wxPenJoin join)
 {
-    m_refData = new wxPenRefData;
+    switch( join )
+    {
+        case wxJOIN_BEVEL:
+            return PS_JOIN_BEVEL;
 
-//  M_PENDATA->m_colour = col;
-    M_PENDATA->m_stipple = stipple;
-    M_PENDATA->m_width = Width;
-    M_PENDATA->m_style = wxSTIPPLE;
-    M_PENDATA->m_join = wxJOIN_ROUND ;
-    M_PENDATA->m_cap = wxCAP_ROUND ;
-    M_PENDATA->m_nbDash = 0 ;
-    M_PENDATA->m_dash = (wxDash*)NULL;
-    M_PENDATA->m_hPen = 0 ;
+        case wxJOIN_MITER:
+            return PS_JOIN_MITER;
 
-    RealizeResource();
+        default:
+            wxFAIL_MSG( _T("unknown pen join style") );
+            // fall through
+
+        case wxJOIN_ROUND:
+            return PS_JOIN_ROUND;
+    }
 }
 
-bool wxPen::operator==(const wxPen& pen) const
+static int ConvertCapStyle(wxPenCap cap)
 {
-    const wxPenRefData *penData = wx_static_cast(const wxPenRefData*, pen.m_refData);
+    switch ( cap )
+    {
+        case wxCAP_PROJECTING:
+            return PS_ENDCAP_SQUARE;
 
-    // an invalid pen is only equal to another invalid pen
-    return m_refData ? penData && *M_PENDATA == *penData : !penData;
+        case wxCAP_BUTT:
+            return PS_ENDCAP_FLAT;
+
+        default:
+            wxFAIL_MSG( _T("unknown pen cap style") );
+            // fall through
+
+        case wxCAP_ROUND:
+            return PS_ENDCAP_ROUND;
+    }
 }
 
-bool wxPen::RealizeResource()
+#endif // wxHAVE_EXT_CREATE_PEN
+
+bool wxPenRefData::Alloc()
 {
-   if ( !M_PENDATA || M_PENDATA->m_hPen )
+   if ( m_hPen )
        return false;
 
-   if (M_PENDATA->m_style==wxTRANSPARENT)
+   if ( m_style == wxPENSTYLE_TRANSPARENT )
    {
-       M_PENDATA->m_hPen = (WXHPEN) ::GetStockObject(NULL_PEN);
+       m_hPen = (HPEN)::GetStockObject(NULL_PEN);
        return true;
    }
 
-   static const int os = wxGetOsVersion();
-   COLORREF ms_colour = M_PENDATA->m_colour.GetPixel();
+   const COLORREF col = m_colour.GetPixel();
 
-   // Join style, Cap style, Pen Stippling
-#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
+#ifdef wxHAVE_EXT_CREATE_PEN
    // Only NT can display dashed or dotted lines with width > 1
+   static const int os = wxGetOsVersion();
    if ( os != wxOS_WINDOWS_NT &&
-           (M_PENDATA->m_style == wxDOT ||
-            M_PENDATA->m_style == wxLONG_DASH ||
-            M_PENDATA->m_style == wxSHORT_DASH ||
-            M_PENDATA->m_style == wxDOT_DASH ||
-            M_PENDATA->m_style == wxUSER_DASH) &&
-            M_PENDATA->m_width > 1 )
+           (m_style == wxPENSTYLE_DOT ||
+            m_style == wxPENSTYLE_LONG_DASH ||
+            m_style == wxPENSTYLE_SHORT_DASH ||
+            m_style == wxPENSTYLE_DOT_DASH ||
+            m_style == wxPENSTYLE_USER_DASH) &&
+            m_width > 1 )
    {
-       M_PENDATA->m_width = 1;
+       m_width = 1;
    }
 
-   if (M_PENDATA->m_join==wxJOIN_ROUND        &&
-       M_PENDATA->m_cap==wxCAP_ROUND          &&
-       M_PENDATA->m_style!=wxUSER_DASH        &&
-       M_PENDATA->m_style!=wxSTIPPLE          &&
-       M_PENDATA->m_width <= 1)
+   // check if it's a standard kind of pen which can be created with just
+   // CreatePen()
+   if ( m_join == wxJOIN_ROUND &&
+            m_cap == wxCAP_ROUND &&
+                m_style != wxPENSTYLE_USER_DASH &&
+                    m_style != wxPENSTYLE_STIPPLE &&
+                        (m_width <= 1 || m_style == wxPENSTYLE_SOLID) )
+#endif // !wxHAVE_EXT_CREATE_PEN
    {
-       M_PENDATA->m_hPen =
-         (WXHPEN) CreatePen( wx2msPenStyle(M_PENDATA->m_style),
-                             M_PENDATA->m_width,
-                             ms_colour );
+       m_hPen = ::CreatePen(ConvertPenStyle(m_style), m_width, col);
    }
-   else
+#ifdef wxHAVE_EXT_CREATE_PEN
+   else // need to use ExtCreatePen()
    {
-       DWORD ms_style = PS_GEOMETRIC | wx2msPenStyle(M_PENDATA->m_style);
+       DWORD styleMSW = PS_GEOMETRIC |
+                        ConvertPenStyle(m_style) |
+                        ConvertJoinStyle(m_join) |
+                        ConvertCapStyle(m_cap);
 
-       switch(M_PENDATA->m_join)
+       LOGBRUSH lb;
+       switch( m_style )
        {
-           case wxJOIN_BEVEL: ms_style |= PS_JOIN_BEVEL; break;
-           case wxJOIN_MITER: ms_style |= PS_JOIN_MITER; break;
-           default:
-           case wxJOIN_ROUND: ms_style |= PS_JOIN_ROUND; break;
-       }
-
-       switch(M_PENDATA->m_cap)
-       {
-           case wxCAP_PROJECTING: ms_style |= PS_ENDCAP_SQUARE;  break;
-           case wxCAP_BUTT:       ms_style |= PS_ENDCAP_FLAT;    break;
-           default:
-           case wxCAP_ROUND:      ms_style |= PS_ENDCAP_ROUND;   break;
-       }
-
-       LOGBRUSH logb;
-
-       switch(M_PENDATA->m_style)
-       {
-           case wxSTIPPLE:
-               logb.lbStyle = BS_PATTERN ;
-               if (M_PENDATA->m_stipple.Ok())
-                   logb.lbHatch = (LONG)M_PENDATA->m_stipple.GetHBITMAP();
-               else
-                   logb.lbHatch = (LONG)0;
+           case wxPENSTYLE_STIPPLE:
+               lb.lbStyle = BS_PATTERN;
+               lb.lbHatch = wxPtrToUInt(m_stipple.GetHBITMAP());
                break;
-           case wxBDIAGONAL_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_BDIAGONAL;
+
+           case wxPENSTYLE_BDIAGONAL_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_BDIAGONAL;
                break;
-           case wxCROSSDIAG_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_DIAGCROSS;
+
+           case wxPENSTYLE_CROSSDIAG_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_DIAGCROSS;
                break;
-           case wxFDIAGONAL_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_FDIAGONAL;
+
+           case wxPENSTYLE_FDIAGONAL_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_FDIAGONAL;
                break;
-           case wxCROSS_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_CROSS;
+
+           case wxPENSTYLE_CROSS_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_CROSS;
                break;
-           case wxHORIZONTAL_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_HORIZONTAL;
+
+           case wxPENSTYLE_HORIZONTAL_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_HORIZONTAL;
                break;
-           case wxVERTICAL_HATCH:
-               logb.lbStyle = BS_HATCHED;
-               logb.lbHatch = HS_VERTICAL;
+
+           case wxPENSTYLE_VERTICAL_HATCH:
+               lb.lbStyle = BS_HATCHED;
+               lb.lbHatch = HS_VERTICAL;
                break;
+
            default:
-               logb.lbStyle = BS_SOLID;
+               lb.lbStyle = BS_SOLID;
 #ifdef __WXDEBUG__
-               // this should be unnecessary (it's unused) but suppresses the Purify
-               // messages about uninitialized memory read
-               logb.lbHatch = 0;
+               // this should be unnecessary (it's unused) but suppresses the
+               // Purify messages about uninitialized memory read
+               lb.lbHatch = 0;
 #endif
                break;
        }
 
-       logb.lbColor = ms_colour;
+       lb.lbColor = col;
 
-       wxMSWDash *real_dash;
-       if (M_PENDATA->m_style==wxUSER_DASH && M_PENDATA->m_nbDash && M_PENDATA->m_dash)
+       DWORD *dash;
+       if ( m_style == wxPENSTYLE_USER_DASH && m_nbDash && m_dash )
        {
-           real_dash = new wxMSWDash[M_PENDATA->m_nbDash];
-           int rw = M_PENDATA->m_width > 1 ? M_PENDATA->m_width : 1;
-           for ( int i = 0; i < M_PENDATA->m_nbDash; i++ )
-               real_dash[i] = M_PENDATA->m_dash[i] * rw;
+           dash = new DWORD[m_nbDash];
+           int rw = m_width > 1 ? m_width : 1;
+           for ( int i = 0; i < m_nbDash; i++ )
+               dash[i] = m_dash[i] * rw;
        }
        else
        {
-           real_dash = (wxMSWDash*)NULL;
+           dash = NULL;
        }
 
-       M_PENDATA->m_hPen =
-         (WXHPEN) ExtCreatePen( ms_style,
-                                M_PENDATA->m_width,
-                                &logb,
-                                M_PENDATA->m_style == wxUSER_DASH
-                                  ? M_PENDATA->m_nbDash
-                                  : 0,
-                                (LPDWORD)real_dash );
+       m_hPen = ::ExtCreatePen(styleMSW, m_width, &lb, m_nbDash, (LPDWORD)dash);
 
-       delete [] real_dash;
+       delete [] dash;
    }
-#else // WinCE
-   M_PENDATA->m_hPen =
-     (WXHPEN) CreatePen( wx2msPenStyle(M_PENDATA->m_style),
-                         M_PENDATA->m_width,
-                         ms_colour );
-#endif // !WinCE/WinCE
+#endif // wxHAVE_EXT_CREATE_PEN
+
+   return m_hPen != 0;
+}
+
+bool wxPenRefData::Free()
+{
+    if ( !m_hPen )
+        return false;
 
-   return true;
+    ::DeleteObject(m_hPen);
+    m_hPen = 0;
+
+    return true;
+}
+
+WXHPEN wxPenRefData::GetHPEN() const
+{
+    if ( !m_hPen )
+        wx_const_cast(wxPenRefData *, this)->Alloc();
+
+    return (WXHPEN)m_hPen;
+}
+
+// ----------------------------------------------------------------------------
+// wxPen
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
+
+wxPen::wxPen(const wxColour& col, int width, wxPenStyle style)
+{
+    m_refData = new wxPenRefData(col, width, style);
+}
+
+#if FUTURE_WXWIN_COMPATIBILITY_3_0
+wxPen::wxPen(const wxColour& colour, int width, int style)
+{
+    m_refData = new wxPenRefData(colour, width, (wxPenStyle)style);
+}
+#endif
+
+wxPen::wxPen(const wxBitmap& stipple, int width)
+{
+    m_refData = new wxPenRefData(stipple, width);
+}
+
+bool wxPen::operator==(const wxPen& pen) const
+{
+    const wxPenRefData *
+        penData = wx_static_cast(const wxPenRefData *, pen.m_refData);
+
+    // an invalid pen is only equal to another invalid pen
+    return m_refData ? penData && *M_PENDATA == *penData : !penData;
+}
+
+bool wxPen::RealizeResource()
+{
+    return M_PENDATA && M_PENDATA->Alloc();
 }
 
 WXHANDLE wxPen::GetResourceHandle() const
 {
-    if ( !M_PENDATA )
-        return 0;
-    else
-        return (WXHANDLE)M_PENDATA->m_hPen;
+    return M_PENDATA ? M_PENDATA->GetHPEN() : 0;
 }
 
 bool wxPen::FreeResource(bool WXUNUSED(force))
 {
-    if (M_PENDATA && (M_PENDATA->m_hPen != 0))
-    {
-        DeleteObject((HPEN) M_PENDATA->m_hPen);
-        M_PENDATA->m_hPen = 0;
-        return true;
-    }
-    else return false;
+    return M_PENDATA && M_PENDATA->Free();
 }
 
 bool wxPen::IsFree() const
 {
-    return (M_PENDATA && M_PENDATA->m_hPen == 0);
+    return M_PENDATA && !M_PENDATA->HasHPEN();
 }
 
-wxObjectRefData* wxPen::CreateRefData() const
+wxGDIRefData* wxPen::CreateGDIRefData() const
 {
-    return new wxFontRefData;
+    return new wxPenRefData;
 }
 
-wxObjectRefData* wxPen::CloneRefData(const wxObjectRefData* data) const
+wxGDIRefData* wxPen::CloneGDIRefData(const wxGDIRefData* data) const
 {
-    return new wxFontRefData(*wx_static_cast(const wxPenRefData*, data));
+    return new wxPenRefData(*wx_static_cast(const wxPenRefData*, data));
 }
 
 void wxPen::SetColour(const wxColour& col)
 {
     AllocExclusive();
 
-    M_PENDATA->m_colour = col;
-
-    RealizeResource();
+    M_PENDATA->SetColour(col);
 }
 
 void wxPen::SetColour(unsigned char r, unsigned char g, unsigned char b)
 {
-    AllocExclusive();
-
-    M_PENDATA->m_colour.Set(r, g, b);
-
-    RealizeResource();
+    SetColour(wxColour(r, g, b));
 }
 
-void wxPen::SetWidth(int Width)
+void wxPen::SetWidth(int width)
 {
     AllocExclusive();
 
-    M_PENDATA->m_width = Width;
-
-    RealizeResource();
+    M_PENDATA->SetWidth(width);
 }
 
-void wxPen::SetStyle(int Style)
+void wxPen::SetStyle(wxPenStyle style)
 {
     AllocExclusive();
 
-    M_PENDATA->m_style = Style;
-
-    RealizeResource();
+    M_PENDATA->SetStyle(style);
 }
 
-void wxPen::SetStipple(const wxBitmap& Stipple)
+void wxPen::SetStipple(const wxBitmap& stipple)
 {
     AllocExclusive();
 
-    M_PENDATA->m_stipple = Stipple;
-    M_PENDATA->m_style = wxSTIPPLE;
-
-    RealizeResource();
+    M_PENDATA->SetStipple(stipple);
 }
 
-void wxPen::SetDashes(int nb_dashes, const wxDash *Dash)
+void wxPen::SetDashes(int nb_dashes, const wxDash *dash)
 {
     AllocExclusive();
 
-    M_PENDATA->m_nbDash = nb_dashes;
-    M_PENDATA->m_dash = (wxDash *)Dash;
-
-    RealizeResource();
+    M_PENDATA->SetDashes(nb_dashes, dash);
 }
 
-void wxPen::SetJoin(int Join)
+void wxPen::SetJoin(wxPenJoin join)
 {
     AllocExclusive();
 
-    M_PENDATA->m_join = Join;
-
-    RealizeResource();
+    M_PENDATA->SetJoin(join);
 }
 
-void wxPen::SetCap(int Cap)
+void wxPen::SetCap(wxPenCap cap)
 {
     AllocExclusive();
 
-    M_PENDATA->m_cap = Cap;
-
-    RealizeResource();
+    M_PENDATA->SetCap(cap);
 }
 
-wxColour& wxPen::GetColour() const
+wxColour wxPen::GetColour() const
 {
-    return m_refData ? M_PENDATA->m_colour : wxNullColour;
+    wxCHECK_MSG( Ok(), wxNullColour, wxT("invalid pen") );
+
+    return M_PENDATA->GetColour();
 }
 
 int wxPen::GetWidth() const
 {
-    return m_refData ? M_PENDATA->m_width : 0;
+    wxCHECK_MSG( Ok(), -1, wxT("invalid pen") );
+
+    return M_PENDATA->GetWidth();
 }
 
-int wxPen::GetStyle() const
+wxPenStyle wxPen::GetStyle() const
 {
-    return m_refData ? M_PENDATA->m_style : 0;
+    wxCHECK_MSG( Ok(), wxPENSTYLE_INVALID, wxT("invalid pen") );
+
+    return M_PENDATA->GetStyle();
 }
 
-int wxPen::GetJoin() const
+wxPenJoin wxPen::GetJoin() const
 {
-    return m_refData ? M_PENDATA->m_join : 0;
+    wxCHECK_MSG( Ok(), wxJOIN_INVALID, wxT("invalid pen") );
+
+    return M_PENDATA->GetJoin();
 }
 
-int wxPen::GetCap() const
+wxPenCap wxPen::GetCap() const
 {
-    return m_refData ? M_PENDATA->m_cap : 0;
+    wxCHECK_MSG( Ok(), wxCAP_INVALID, wxT("invalid pen") );
+
+    return M_PENDATA->GetCap();
 }
 
 int wxPen::GetDashes(wxDash** ptr) const
 {
-    *ptr = NULL;
-    int count = 0;
-    if (m_refData)
-    {
-        *ptr = M_PENDATA->m_dash;
-        count = M_PENDATA->m_nbDash;
-    }
-    return count;
+    wxCHECK_MSG( Ok(), -1, wxT("invalid pen") );
+
+    *ptr = M_PENDATA->GetDash();
+    return M_PENDATA->GetDashCount();
 }
 
 wxDash* wxPen::GetDash() const
 {
-    wxDash* dash = NULL;
-    if (m_refData)
-        dash = M_PENDATA->m_dash;
-    return dash;
+    wxCHECK_MSG( Ok(), NULL, wxT("invalid pen") );
+
+    return m_refData ? M_PENDATA->GetDash() : NULL;
 }
 
 int wxPen::GetDashCount() const
 {
-    return m_refData ? M_PENDATA->m_nbDash : 0;
-}
+    wxCHECK_MSG( Ok(), -1, wxT("invalid pen") );
 
-wxBitmap* wxPen::GetStipple() const
-{
-    wxBitmap* bitmap = NULL;
-    if (m_refData)
-        bitmap = &M_PENDATA->m_stipple;
-    return bitmap;
+    return m_refData ? M_PENDATA->GetDashCount() : 0;
 }
 
-int wx2msPenStyle(int wx_style)
+wxBitmap* wxPen::GetStipple() const
 {
-#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
-    switch (wx_style)
-    {
-        case wxDOT:
-            return PS_DOT;
+    wxCHECK_MSG( Ok(), NULL, wxT("invalid pen") );
 
-        case wxDOT_DASH:
-            return PS_DASHDOT;
-
-        case wxSHORT_DASH:
-        case wxLONG_DASH:
-            return PS_DASH;
-
-        case wxTRANSPARENT:
-            return PS_NULL;
-
-        case wxUSER_DASH:
-            return PS_USERSTYLE;
-    }
-#else
-    wxUnusedVar(wx_style);
-#endif
-    return PS_SOLID;
+    return m_refData ? M_PENDATA->GetStipple() : NULL;
 }