src/msw/pen.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/pen.cpp
// Purpose:     wxPen
// Author:      Julian Smart
// Modified by: Vadim Zeitlin: refactored wxPen code to wxPenRefData
// Created:     04/01/98
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/pen.h"

#ifndef WX_PRECOMP
    #include "wx/bitmap.h"
    #include "wx/utils.h"
#endif

#include "wx/msw/private.h"

#define M_PENDATA ((wxPenRefData*)m_refData)

// Win32 has ExtCreatePen() but WinCE doesn't
#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
    #define wxHAVE_EXT_CREATE_PEN
#endif

// ----------------------------------------------------------------------------
// 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
    {
        // we intentionally don't compare m_hPen fields here
        return m_style == data.m_style &&
               m_width == data.m_width &&
               m_join == data.m_join &&
               m_cap == data.m_cap &&
               m_colour == data.m_colour &&
               (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 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 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 = 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;
    wxPenStyle    m_style;
    wxPenJoin     m_join;
    wxPenCap      m_cap;
    wxBitmap      m_stipple;
    int           m_nbDash;
    wxDash *      m_dash;
    wxColour      m_colour;
    HPEN          m_hPen;

    wxDECLARE_NO_ASSIGN_CLASS(wxPenRefData);
};

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxPenRefData ctors/dtor
// ----------------------------------------------------------------------------

wxPenRefData::wxPenRefData()
{
    Init();

    m_style = wxPENSTYLE_SOLID;
    m_width = 1;
}

wxPenRefData::wxPenRefData(const wxPenRefData& data)
             :wxGDIRefData()
{
    m_style = data.m_style;
    m_width = data.m_width;
    m_join = data.m_join;
    m_cap = data.m_cap;
    m_nbDash = data.m_nbDash;
    m_dash = data.m_dash;
    m_colour = data.m_colour;
    m_hPen = 0;
}

wxPenRefData::wxPenRefData(const wxColour& col, int width, wxPenStyle style)
{
    Init();

    m_style = style;
    m_width = width;

    m_colour = col;
}

wxPenRefData::wxPenRefData(const wxBitmap& stipple, int width)
{
    Init();

    m_style = wxPENSTYLE_STIPPLE;
    m_width = width;

    m_stipple = stipple;
}

wxPenRefData::~wxPenRefData()
{
    if ( m_hPen )
        ::DeleteObject(m_hPen);
}

// ----------------------------------------------------------------------------
// wxPenRefData HPEN management
// ----------------------------------------------------------------------------

static int ConvertPenStyle(wxPenStyle style)
{
    switch ( style )
    {
        case wxPENSTYLE_SHORT_DASH:
        case wxPENSTYLE_LONG_DASH:
            return PS_DASH;

        case wxPENSTYLE_TRANSPARENT:
            return PS_NULL;

        default:
            wxFAIL_MSG( wxT("unknown pen style") );
            // fall through

#ifdef wxHAVE_EXT_CREATE_PEN
        case wxPENSTYLE_DOT:
            return PS_DOT;

        case wxPENSTYLE_DOT_DASH:
            return PS_DASHDOT;

        case wxPENSTYLE_USER_DASH:
            return PS_USERSTYLE;

        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;
    }
}

#ifdef wxHAVE_EXT_CREATE_PEN

static int ConvertJoinStyle(wxPenJoin join)
{
    switch( join )
    {
        case wxJOIN_BEVEL:
            return PS_JOIN_BEVEL;

        case wxJOIN_MITER:
            return PS_JOIN_MITER;

        default:
            wxFAIL_MSG( wxT("unknown pen join style") );
            // fall through

        case wxJOIN_ROUND:
            return PS_JOIN_ROUND;
    }
}

static int ConvertCapStyle(wxPenCap cap)
{
    switch ( cap )
    {
        case wxCAP_PROJECTING:
            return PS_ENDCAP_SQUARE;

        case wxCAP_BUTT:
            return PS_ENDCAP_FLAT;

        default:
            wxFAIL_MSG( wxT("unknown pen cap style") );
            // fall through

        case wxCAP_ROUND:
            return PS_ENDCAP_ROUND;
    }
}

#endif // wxHAVE_EXT_CREATE_PEN

bool wxPenRefData::Alloc()
{
   if ( m_hPen )
       return false;

   if ( m_style == wxPENSTYLE_TRANSPARENT )
   {
       m_hPen = (HPEN)::GetStockObject(NULL_PEN);
       return true;
   }

   const COLORREF col = m_colour.GetPixel();

#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_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_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_hPen = ::CreatePen(ConvertPenStyle(m_style), m_width, col);
   }
#ifdef wxHAVE_EXT_CREATE_PEN
   else // need to use ExtCreatePen()
   {
       DWORD styleMSW = PS_GEOMETRIC |
                        ConvertPenStyle(m_style) |
                        ConvertJoinStyle(m_join) |
                        ConvertCapStyle(m_cap);

       LOGBRUSH lb;
       switch( m_style )
       {
           case wxPENSTYLE_STIPPLE:
               lb.lbStyle = BS_PATTERN;
               lb.lbHatch = wxPtrToUInt(m_stipple.GetHBITMAP());
               break;

           case wxPENSTYLE_BDIAGONAL_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_BDIAGONAL;
               break;

           case wxPENSTYLE_CROSSDIAG_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_DIAGCROSS;
               break;

           case wxPENSTYLE_FDIAGONAL_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_FDIAGONAL;
               break;

           case wxPENSTYLE_CROSS_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_CROSS;
               break;

           case wxPENSTYLE_HORIZONTAL_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_HORIZONTAL;
               break;

           case wxPENSTYLE_VERTICAL_HATCH:
               lb.lbStyle = BS_HATCHED;
               lb.lbHatch = HS_VERTICAL;
               break;

           default:
               lb.lbStyle = BS_SOLID;
               // this should be unnecessary (it's unused) but suppresses the
               // Purify messages about uninitialized memory read
               lb.lbHatch = 0;
               break;
       }

       lb.lbColor = col;

       DWORD *dash;
       if ( m_style == wxPENSTYLE_USER_DASH && m_nbDash && m_dash )
       {
           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
       {
           dash = NULL;
       }

       m_hPen = ::ExtCreatePen(styleMSW, m_width, &lb, m_nbDash, (LPDWORD)dash);

       delete [] dash;
   }
#endif // wxHAVE_EXT_CREATE_PEN

   return m_hPen != 0;
}

bool wxPenRefData::Free()
{
    if ( !m_hPen )
        return false;

    ::DeleteObject(m_hPen);
    m_hPen = 0;

    return true;
}

WXHPEN wxPenRefData::GetHPEN() const
{
    if ( !m_hPen )
        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 = 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
{
    return M_PENDATA ? M_PENDATA->GetHPEN() : 0;
}

bool wxPen::FreeResource(bool WXUNUSED(force))
{
    return M_PENDATA && M_PENDATA->Free();
}

bool wxPen::IsFree() const
{
    return M_PENDATA && !M_PENDATA->HasHPEN();
}

wxGDIRefData* wxPen::CreateGDIRefData() const
{
    return new wxPenRefData;
}

wxGDIRefData* wxPen::CloneGDIRefData(const wxGDIRefData* data) const
{
    return new wxPenRefData(*static_cast<const wxPenRefData*>(data));
}

void wxPen::SetColour(const wxColour& col)
{
    AllocExclusive();

    M_PENDATA->SetColour(col);
}

void wxPen::SetColour(unsigned char r, unsigned char g, unsigned char b)
{
    SetColour(wxColour(r, g, b));
}

void wxPen::SetWidth(int width)
{
    AllocExclusive();

    M_PENDATA->SetWidth(width);
}

void wxPen::SetStyle(wxPenStyle style)
{
    AllocExclusive();

    M_PENDATA->SetStyle(style);
}

void wxPen::SetStipple(const wxBitmap& stipple)
{
    AllocExclusive();

    M_PENDATA->SetStipple(stipple);
}

void wxPen::SetDashes(int nb_dashes, const wxDash *dash)
{
    AllocExclusive();

    M_PENDATA->SetDashes(nb_dashes, dash);
}

void wxPen::SetJoin(wxPenJoin join)
{
    AllocExclusive();

    M_PENDATA->SetJoin(join);
}

void wxPen::SetCap(wxPenCap cap)
{
    AllocExclusive();

    M_PENDATA->SetCap(cap);
}

wxColour wxPen::GetColour() const
{
    wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid pen") );

    return M_PENDATA->GetColour();
}

int wxPen::GetWidth() const
{
    wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );

    return M_PENDATA->GetWidth();
}

wxPenStyle wxPen::GetStyle() const
{
    wxCHECK_MSG( IsOk(), wxPENSTYLE_INVALID, wxT("invalid pen") );

    return M_PENDATA->GetStyle();
}

wxPenJoin wxPen::GetJoin() const
{
    wxCHECK_MSG( IsOk(), wxJOIN_INVALID, wxT("invalid pen") );

    return M_PENDATA->GetJoin();
}

wxPenCap wxPen::GetCap() const
{
    wxCHECK_MSG( IsOk(), wxCAP_INVALID, wxT("invalid pen") );

    return M_PENDATA->GetCap();
}

int wxPen::GetDashes(wxDash** ptr) const
{
    wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );

    *ptr = M_PENDATA->GetDash();
    return M_PENDATA->GetDashCount();
}

wxDash* wxPen::GetDash() const
{
    wxCHECK_MSG( IsOk(), NULL, wxT("invalid pen") );

    return m_refData ? M_PENDATA->GetDash() : NULL;
}

int wxPen::GetDashCount() const
{
    wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );

    return m_refData ? M_PENDATA->GetDashCount() : 0;
}

wxBitmap* wxPen::GetStipple() const
{
    wxCHECK_MSG( IsOk(), NULL, wxT("invalid pen") );

    return m_refData ? M_PENDATA->GetStipple() : NULL;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/pen.cpp
	3	// Purpose: wxPen
	4	// Author: Julian Smart
	5	// Modified by: Vadim Zeitlin: refactored wxPen code to wxPenRefData
	6	// Created: 04/01/98
	7	// Copyright: (c) Julian Smart
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// ============================================================================
	12	// declarations
	13	// ============================================================================
	14
	15	// ----------------------------------------------------------------------------
	16	// headers
	17	// ----------------------------------------------------------------------------
	18
	19	// For compilers that support precompilation, includes "wx.h".
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#include "wx/pen.h"
	27
	28	#ifndef WX_PRECOMP
	29	#include "wx/bitmap.h"
	30	#include "wx/utils.h"
	31	#endif
	32
	33	#include "wx/msw/private.h"
	34
	35	#define M_PENDATA ((wxPenRefData*)m_refData)
	36
	37	// Win32 has ExtCreatePen() but WinCE doesn't
	38	#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
	39	#define wxHAVE_EXT_CREATE_PEN
	40	#endif
	41
	42	// ----------------------------------------------------------------------------
	43	// wxPenRefData: contains information about an HPEN and its handle
	44	// ----------------------------------------------------------------------------
	45
	46	class WXDLLEXPORT wxPenRefData : public wxGDIRefData
	47	{
	48	public:
	49	// ctors and dtor
	50	// --------------
	51
	52	wxPenRefData();
	53	wxPenRefData(const wxPenRefData& data);
	54	wxPenRefData(const wxColour& col, int width, wxPenStyle style);
	55	wxPenRefData(const wxBitmap& stipple, int width);
	56	virtual ~wxPenRefData();
	57
	58	bool operator==(const wxPenRefData& data) const
	59	{
	60	// we intentionally don't compare m_hPen fields here
	61	return m_style == data.m_style &&
	62	m_width == data.m_width &&
	63	m_join == data.m_join &&
	64	m_cap == data.m_cap &&
	65	m_colour == data.m_colour &&
	66	(m_style != wxPENSTYLE_STIPPLE \|\| m_stipple.IsSameAs(data.m_stipple)) &&
	67	(m_style != wxPENSTYLE_USER_DASH \|\|
	68	(m_nbDash == data.m_nbDash &&
	69	memcmp(m_dash, data.m_dash, m_nbDash*sizeof(wxDash)) == 0));
	70	}
	71
	72
	73	// accessors and setters
	74	// ---------------------
	75
	76	wxColour& GetColour() const { return const_cast<wxColour&>(m_colour); }
	77	int GetWidth() const { return m_width; }
	78	wxPenStyle GetStyle() const { return m_style; }
	79	wxPenJoin GetJoin() const { return m_join; }
	80	wxPenCap GetCap() const { return m_cap; }
	81	wxDash* GetDash() const { return m_dash; }
	82	int GetDashCount() const { return m_nbDash; }
	83	wxBitmap* GetStipple() const { return const_cast<wxBitmap *>(&m_stipple); }
	84
	85	void SetColour(const wxColour& col) { Free(); m_colour = col; }
	86	void SetWidth(int width) { Free(); m_width = width; }
	87	void SetStyle(wxPenStyle style) { Free(); m_style = style; }
	88	void SetStipple(const wxBitmap& stipple)
	89	{
	90	Free();
	91
	92	m_style = wxPENSTYLE_STIPPLE;
	93	m_stipple = stipple;
	94	}
	95
	96	void SetDashes(int nb_dashes, const wxDash *dash)
	97	{
	98	Free();
	99
	100	m_nbDash = nb_dashes;
	101	m_dash = const_cast<wxDash *>(dash);
	102	}
	103
	104	void SetJoin(wxPenJoin join) { Free(); m_join = join; }
	105	void SetCap(wxPenCap cap) { Free(); m_cap = cap; }
	106
	107
	108	// HPEN management
	109	// ---------------
	110
	111	// create the HPEN if we don't have it yet
	112	bool Alloc();
	113
	114	// get the HPEN creating it on demand
	115	WXHPEN GetHPEN() const;
	116
	117	// return true if we have a valid HPEN
	118	bool HasHPEN() const { return m_hPen != 0; }
	119
	120	// return true if we had a valid handle before, false otherwise
	121	bool Free();
	122
	123	private:
	124	// initialize the fields which have reasonable default values
	125	//
	126	// doesn't initialize m_width and m_style which must be initialize in ctor
	127	void Init()
	128	{
	129	m_join = wxJOIN_ROUND;
	130	m_cap = wxCAP_ROUND;
	131	m_nbDash = 0;
	132	m_dash = NULL;
	133	m_hPen = 0;
	134	}
	135
	136	int m_width;
	137	wxPenStyle m_style;
	138	wxPenJoin m_join;
	139	wxPenCap m_cap;
	140	wxBitmap m_stipple;
	141	int m_nbDash;
	142	wxDash * m_dash;
	143	wxColour m_colour;
	144	HPEN m_hPen;
	145
	146	wxDECLARE_NO_ASSIGN_CLASS(wxPenRefData);
	147	};
	148
	149	// ============================================================================
	150	// implementation
	151	// ============================================================================
	152
	153	// ----------------------------------------------------------------------------
	154	// wxPenRefData ctors/dtor
	155	// ----------------------------------------------------------------------------
	156
	157	wxPenRefData::wxPenRefData()
	158	{
	159	Init();
	160
	161	m_style = wxPENSTYLE_SOLID;
	162	m_width = 1;
	163	}
	164
	165	wxPenRefData::wxPenRefData(const wxPenRefData& data)
	166	:wxGDIRefData()
	167	{
	168	m_style = data.m_style;
	169	m_width = data.m_width;
	170	m_join = data.m_join;
	171	m_cap = data.m_cap;
	172	m_nbDash = data.m_nbDash;
	173	m_dash = data.m_dash;
	174	m_colour = data.m_colour;
	175	m_hPen = 0;
	176	}
	177
	178	wxPenRefData::wxPenRefData(const wxColour& col, int width, wxPenStyle style)
	179	{
	180	Init();
	181
	182	m_style = style;
	183	m_width = width;
	184
	185	m_colour = col;
	186	}
	187
	188	wxPenRefData::wxPenRefData(const wxBitmap& stipple, int width)
	189	{
	190	Init();
	191
	192	m_style = wxPENSTYLE_STIPPLE;
	193	m_width = width;
	194
	195	m_stipple = stipple;
	196	}
	197
	198	wxPenRefData::~wxPenRefData()
	199	{
	200	if ( m_hPen )
	201	::DeleteObject(m_hPen);
	202	}
	203
	204	// ----------------------------------------------------------------------------
	205	// wxPenRefData HPEN management
	206	// ----------------------------------------------------------------------------
	207
	208	static int ConvertPenStyle(wxPenStyle style)
	209	{
	210	switch ( style )
	211	{
	212	case wxPENSTYLE_SHORT_DASH:
	213	case wxPENSTYLE_LONG_DASH:
	214	return PS_DASH;
	215
	216	case wxPENSTYLE_TRANSPARENT:
	217	return PS_NULL;
	218
	219	default:
	220	wxFAIL_MSG( wxT("unknown pen style") );
	221	// fall through
	222
	223	#ifdef wxHAVE_EXT_CREATE_PEN
	224	case wxPENSTYLE_DOT:
	225	return PS_DOT;
	226
	227	case wxPENSTYLE_DOT_DASH:
	228	return PS_DASHDOT;
	229
	230	case wxPENSTYLE_USER_DASH:
	231	return PS_USERSTYLE;
	232
	233	case wxPENSTYLE_STIPPLE:
	234	case wxPENSTYLE_BDIAGONAL_HATCH:
	235	case wxPENSTYLE_CROSSDIAG_HATCH:
	236	case wxPENSTYLE_FDIAGONAL_HATCH:
	237	case wxPENSTYLE_CROSS_HATCH:
	238	case wxPENSTYLE_HORIZONTAL_HATCH:
	239	case wxPENSTYLE_VERTICAL_HATCH:
	240	case wxPENSTYLE_SOLID:
	241	#endif // wxHAVE_EXT_CREATE_PEN
	242
	243	return PS_SOLID;
	244	}
	245	}
	246
	247	#ifdef wxHAVE_EXT_CREATE_PEN
	248
	249	static int ConvertJoinStyle(wxPenJoin join)
	250	{
	251	switch( join )
	252	{
	253	case wxJOIN_BEVEL:
	254	return PS_JOIN_BEVEL;
	255
	256	case wxJOIN_MITER:
	257	return PS_JOIN_MITER;
	258
	259	default:
	260	wxFAIL_MSG( wxT("unknown pen join style") );
	261	// fall through
	262
	263	case wxJOIN_ROUND:
	264	return PS_JOIN_ROUND;
	265	}
	266	}
	267
	268	static int ConvertCapStyle(wxPenCap cap)
	269	{
	270	switch ( cap )
	271	{
	272	case wxCAP_PROJECTING:
	273	return PS_ENDCAP_SQUARE;
	274
	275	case wxCAP_BUTT:
	276	return PS_ENDCAP_FLAT;
	277
	278	default:
	279	wxFAIL_MSG( wxT("unknown pen cap style") );
	280	// fall through
	281
	282	case wxCAP_ROUND:
	283	return PS_ENDCAP_ROUND;
	284	}
	285	}
	286
	287	#endif // wxHAVE_EXT_CREATE_PEN
	288
	289	bool wxPenRefData::Alloc()
	290	{
	291	if ( m_hPen )
	292	return false;
	293
	294	if ( m_style == wxPENSTYLE_TRANSPARENT )
	295	{
	296	m_hPen = (HPEN)::GetStockObject(NULL_PEN);
	297	return true;
	298	}
	299
	300	const COLORREF col = m_colour.GetPixel();
	301
	302	#ifdef wxHAVE_EXT_CREATE_PEN
	303	// Only NT can display dashed or dotted lines with width > 1
	304	static const int os = wxGetOsVersion();
	305	if ( os != wxOS_WINDOWS_NT &&
	306	(m_style == wxPENSTYLE_DOT \|\|
	307	m_style == wxPENSTYLE_LONG_DASH \|\|
	308	m_style == wxPENSTYLE_SHORT_DASH \|\|
	309	m_style == wxPENSTYLE_DOT_DASH \|\|
	310	m_style == wxPENSTYLE_USER_DASH) &&
	311	m_width > 1 )
	312	{
	313	m_width = 1;
	314	}
	315
	316	// check if it's a standard kind of pen which can be created with just
	317	// CreatePen()
	318	if ( m_join == wxJOIN_ROUND &&
	319	m_cap == wxCAP_ROUND &&
	320	m_style != wxPENSTYLE_USER_DASH &&
	321	m_style != wxPENSTYLE_STIPPLE &&
	322	(m_width <= 1 \|\| m_style == wxPENSTYLE_SOLID) )
	323	#endif // !wxHAVE_EXT_CREATE_PEN
	324	{
	325	m_hPen = ::CreatePen(ConvertPenStyle(m_style), m_width, col);
	326	}
	327	#ifdef wxHAVE_EXT_CREATE_PEN
	328	else // need to use ExtCreatePen()
	329	{
	330	DWORD styleMSW = PS_GEOMETRIC \|
	331	ConvertPenStyle(m_style) \|
	332	ConvertJoinStyle(m_join) \|
	333	ConvertCapStyle(m_cap);
	334
	335	LOGBRUSH lb;
	336	switch( m_style )
	337	{
	338	case wxPENSTYLE_STIPPLE:
	339	lb.lbStyle = BS_PATTERN;
	340	lb.lbHatch = wxPtrToUInt(m_stipple.GetHBITMAP());
	341	break;
	342
	343	case wxPENSTYLE_BDIAGONAL_HATCH:
	344	lb.lbStyle = BS_HATCHED;
	345	lb.lbHatch = HS_BDIAGONAL;
	346	break;
	347
	348	case wxPENSTYLE_CROSSDIAG_HATCH:
	349	lb.lbStyle = BS_HATCHED;
	350	lb.lbHatch = HS_DIAGCROSS;
	351	break;
	352
	353	case wxPENSTYLE_FDIAGONAL_HATCH:
	354	lb.lbStyle = BS_HATCHED;
	355	lb.lbHatch = HS_FDIAGONAL;
	356	break;
	357
	358	case wxPENSTYLE_CROSS_HATCH:
	359	lb.lbStyle = BS_HATCHED;
	360	lb.lbHatch = HS_CROSS;
	361	break;
	362
	363	case wxPENSTYLE_HORIZONTAL_HATCH:
	364	lb.lbStyle = BS_HATCHED;
	365	lb.lbHatch = HS_HORIZONTAL;
	366	break;
	367
	368	case wxPENSTYLE_VERTICAL_HATCH:
	369	lb.lbStyle = BS_HATCHED;
	370	lb.lbHatch = HS_VERTICAL;
	371	break;
	372
	373	default:
	374	lb.lbStyle = BS_SOLID;
	375	// this should be unnecessary (it's unused) but suppresses the
	376	// Purify messages about uninitialized memory read
	377	lb.lbHatch = 0;
	378	break;
	379	}
	380
	381	lb.lbColor = col;
	382
	383	DWORD *dash;
	384	if ( m_style == wxPENSTYLE_USER_DASH && m_nbDash && m_dash )
	385	{
	386	dash = new DWORD[m_nbDash];
	387	int rw = m_width > 1 ? m_width : 1;
	388	for ( int i = 0; i < m_nbDash; i++ )
	389	dash[i] = m_dash[i] * rw;
	390	}
	391	else
	392	{
	393	dash = NULL;
	394	}
	395
	396	m_hPen = ::ExtCreatePen(styleMSW, m_width, &lb, m_nbDash, (LPDWORD)dash);
	397
	398	delete [] dash;
	399	}
	400	#endif // wxHAVE_EXT_CREATE_PEN
	401
	402	return m_hPen != 0;
	403	}
	404
	405	bool wxPenRefData::Free()
	406	{
	407	if ( !m_hPen )
	408	return false;
	409
	410	::DeleteObject(m_hPen);
	411	m_hPen = 0;
	412
	413	return true;
	414	}
	415
	416	WXHPEN wxPenRefData::GetHPEN() const
	417	{
	418	if ( !m_hPen )
	419	const_cast<wxPenRefData *>(this)->Alloc();
	420
	421	return (WXHPEN)m_hPen;
	422	}
	423
	424	// ----------------------------------------------------------------------------
	425	// wxPen
	426	// ----------------------------------------------------------------------------
	427
	428	IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
	429
	430	wxPen::wxPen(const wxColour& col, int width, wxPenStyle style)
	431	{
	432	m_refData = new wxPenRefData(col, width, style);
	433	}
	434
	435	#if FUTURE_WXWIN_COMPATIBILITY_3_0
	436	wxPen::wxPen(const wxColour& colour, int width, int style)
	437	{
	438	m_refData = new wxPenRefData(colour, width, (wxPenStyle)style);
	439	}
	440	#endif
	441
	442	wxPen::wxPen(const wxBitmap& stipple, int width)
	443	{
	444	m_refData = new wxPenRefData(stipple, width);
	445	}
	446
	447	bool wxPen::operator==(const wxPen& pen) const
	448	{
	449	const wxPenRefData *
	450	penData = static_cast<const wxPenRefData *>(pen.m_refData);
	451
	452	// an invalid pen is only equal to another invalid pen
	453	return m_refData ? penData && M_PENDATA == penData : !penData;
	454	}
	455
	456	bool wxPen::RealizeResource()
	457	{
	458	return M_PENDATA && M_PENDATA->Alloc();
	459	}
	460
	461	WXHANDLE wxPen::GetResourceHandle() const
	462	{
	463	return M_PENDATA ? M_PENDATA->GetHPEN() : 0;
	464	}
	465
	466	bool wxPen::FreeResource(bool WXUNUSED(force))
	467	{
	468	return M_PENDATA && M_PENDATA->Free();
	469	}
	470
	471	bool wxPen::IsFree() const
	472	{
	473	return M_PENDATA && !M_PENDATA->HasHPEN();
	474	}
	475
	476	wxGDIRefData* wxPen::CreateGDIRefData() const
	477	{
	478	return new wxPenRefData;
	479	}
	480
	481	wxGDIRefData* wxPen::CloneGDIRefData(const wxGDIRefData* data) const
	482	{
	483	return new wxPenRefData(static_cast<const wxPenRefData>(data));
	484	}
	485
	486	void wxPen::SetColour(const wxColour& col)
	487	{
	488	AllocExclusive();
	489
	490	M_PENDATA->SetColour(col);
	491	}
	492
	493	void wxPen::SetColour(unsigned char r, unsigned char g, unsigned char b)
	494	{
	495	SetColour(wxColour(r, g, b));
	496	}
	497
	498	void wxPen::SetWidth(int width)
	499	{
	500	AllocExclusive();
	501
	502	M_PENDATA->SetWidth(width);
	503	}
	504
	505	void wxPen::SetStyle(wxPenStyle style)
	506	{
	507	AllocExclusive();
	508
	509	M_PENDATA->SetStyle(style);
	510	}
	511
	512	void wxPen::SetStipple(const wxBitmap& stipple)
	513	{
	514	AllocExclusive();
	515
	516	M_PENDATA->SetStipple(stipple);
	517	}
	518
	519	void wxPen::SetDashes(int nb_dashes, const wxDash *dash)
	520	{
	521	AllocExclusive();
	522
	523	M_PENDATA->SetDashes(nb_dashes, dash);
	524	}
	525
	526	void wxPen::SetJoin(wxPenJoin join)
	527	{
	528	AllocExclusive();
	529
	530	M_PENDATA->SetJoin(join);
	531	}
	532
	533	void wxPen::SetCap(wxPenCap cap)
	534	{
	535	AllocExclusive();
	536
	537	M_PENDATA->SetCap(cap);
	538	}
	539
	540	wxColour wxPen::GetColour() const
	541	{
	542	wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid pen") );
	543
	544	return M_PENDATA->GetColour();
	545	}
	546
	547	int wxPen::GetWidth() const
	548	{
	549	wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );
	550
	551	return M_PENDATA->GetWidth();
	552	}
	553
	554	wxPenStyle wxPen::GetStyle() const
	555	{
	556	wxCHECK_MSG( IsOk(), wxPENSTYLE_INVALID, wxT("invalid pen") );
	557
	558	return M_PENDATA->GetStyle();
	559	}
	560
	561	wxPenJoin wxPen::GetJoin() const
	562	{
	563	wxCHECK_MSG( IsOk(), wxJOIN_INVALID, wxT("invalid pen") );
	564
	565	return M_PENDATA->GetJoin();
	566	}
	567
	568	wxPenCap wxPen::GetCap() const
	569	{
	570	wxCHECK_MSG( IsOk(), wxCAP_INVALID, wxT("invalid pen") );
	571
	572	return M_PENDATA->GetCap();
	573	}
	574
	575	int wxPen::GetDashes(wxDash** ptr) const
	576	{
	577	wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );
	578
	579	*ptr = M_PENDATA->GetDash();
	580	return M_PENDATA->GetDashCount();
	581	}
	582
	583	wxDash* wxPen::GetDash() const
	584	{
	585	wxCHECK_MSG( IsOk(), NULL, wxT("invalid pen") );
	586
	587	return m_refData ? M_PENDATA->GetDash() : NULL;
	588	}
	589
	590	int wxPen::GetDashCount() const
	591	{
	592	wxCHECK_MSG( IsOk(), -1, wxT("invalid pen") );
	593
	594	return m_refData ? M_PENDATA->GetDashCount() : 0;
	595	}
	596
	597	wxBitmap* wxPen::GetStipple() const
	598	{
	599	wxCHECK_MSG( IsOk(), NULL, wxT("invalid pen") );
	600
	601	return m_refData ? M_PENDATA->GetStipple() : NULL;
	602	}