You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
713 lines
21 KiB
C++
713 lines
21 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: genergdi.cpp
|
|
// Purpose: Generic gdi pen and colour
|
|
// Author: John Labenski
|
|
// Modified by:
|
|
// Created: 12/01/2000
|
|
// Copyright: (c) John Labenski
|
|
// Licence: wxWidgets license
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
|
|
#pragma implementation "genergdi.h"
|
|
#endif
|
|
|
|
// For compilers that support precompilation, includes "wx.h".
|
|
#include "wx/wxprec.h"
|
|
|
|
#ifdef __BORLANDC__
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
#include "wx/things/genergdi.h"
|
|
#include "wx/tokenzr.h"
|
|
|
|
const wxGenericColour wxNullGenericColour;
|
|
const wxGenericPen wxNullGenericPen;
|
|
const wxGenericBrush wxNullGenericBrush;
|
|
#include "wx/arrimpl.cpp"
|
|
WX_DEFINE_OBJARRAY(wxArrayGenericColour)
|
|
WX_DEFINE_OBJARRAY(wxArrayGenericPen)
|
|
WX_DEFINE_OBJARRAY(wxArrayGenericBrush)
|
|
|
|
//----------------------------------------------------------------------------
|
|
// wxGenericColour
|
|
//----------------------------------------------------------------------------
|
|
IMPLEMENT_DYNAMIC_CLASS(wxGenericColour, wxObject)
|
|
|
|
class wxGenericColourRefData : public wxObjectRefData
|
|
{
|
|
public:
|
|
wxGenericColourRefData(unsigned char r = 0, unsigned char g = 0,
|
|
unsigned char b = 0, unsigned char a = 255)
|
|
: wxObjectRefData(), m_r(r), m_g(g), m_b(b), m_a(a) {}
|
|
|
|
wxGenericColourRefData( const wxGenericColourRefData& data )
|
|
: wxObjectRefData(), m_r(data.m_r), m_g(data.m_g), m_b(data.m_b), m_a(data.m_a) {}
|
|
|
|
unsigned char m_r, m_g, m_b, m_a;
|
|
};
|
|
|
|
#define M_GCOLOURDATA ((wxGenericColourRefData*)m_refData)
|
|
|
|
//----------------------------------------------------------------------------
|
|
wxObjectRefData *wxGenericColour::CreateRefData() const
|
|
{
|
|
return new wxGenericColourRefData;
|
|
}
|
|
wxObjectRefData *wxGenericColour::CloneRefData(const wxObjectRefData *data) const
|
|
{
|
|
return new wxGenericColourRefData(*(const wxGenericColourRefData *)data);
|
|
}
|
|
|
|
void wxGenericColour::Create( const wxGenericColour& c )
|
|
{
|
|
Ref(c);
|
|
}
|
|
void wxGenericColour::Create( const wxColour& c)
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericColourRefData;
|
|
Set(c);
|
|
}
|
|
void wxGenericColour::Create( unsigned char red, unsigned char green,
|
|
unsigned char blue, unsigned char alpha )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericColourRefData(red, green, blue, alpha);
|
|
}
|
|
void wxGenericColour::CreateABGR( unsigned long colABGR )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericColourRefData;
|
|
SetABGR(colABGR);
|
|
}
|
|
void wxGenericColour::CreateARGB( unsigned long colARGB )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericColourRefData;
|
|
SetARGB(colARGB);
|
|
}
|
|
void wxGenericColour::Create( const wxString& colourName )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericColourRefData;
|
|
Set(colourName);
|
|
}
|
|
|
|
void wxGenericColour::Set( const wxGenericColour &c )
|
|
{
|
|
wxCHECK_RET(Ok() && c.Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_r = c.GetRed();
|
|
M_GCOLOURDATA->m_g = c.GetGreen();
|
|
M_GCOLOURDATA->m_b = c.GetBlue();
|
|
M_GCOLOURDATA->m_a = c.GetAlpha();
|
|
}
|
|
void wxGenericColour::Set( const wxColour& c )
|
|
{
|
|
wxCHECK_RET(Ok() && c.Ok(), wxT("Invalid colour"));
|
|
M_GCOLOURDATA->m_r = c.Red();
|
|
M_GCOLOURDATA->m_g = c.Green();
|
|
M_GCOLOURDATA->m_b = c.Blue();
|
|
}
|
|
void wxGenericColour::Set( unsigned char red, unsigned char green,
|
|
unsigned char blue, unsigned char alpha )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_r = red;
|
|
M_GCOLOURDATA->m_g = green;
|
|
M_GCOLOURDATA->m_b = blue;
|
|
M_GCOLOURDATA->m_a = alpha;
|
|
}
|
|
void wxGenericColour::SetABGR( unsigned long colABGR )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_r = (unsigned char)(0xFF& colABGR);
|
|
M_GCOLOURDATA->m_g = (unsigned char)(0xFF&(colABGR >> 8));
|
|
M_GCOLOURDATA->m_b = (unsigned char)(0xFF&(colABGR >> 16));
|
|
M_GCOLOURDATA->m_a = (unsigned char)(0xFF&(colABGR >> 24));
|
|
}
|
|
void wxGenericColour::SetARGB( unsigned long colARGB )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_b = (unsigned char)(0xFF& colARGB);
|
|
M_GCOLOURDATA->m_g = (unsigned char)(0xFF&(colARGB >> 8));
|
|
M_GCOLOURDATA->m_r = (unsigned char)(0xFF&(colARGB >> 16));
|
|
M_GCOLOURDATA->m_a = (unsigned char)(0xFF&(colARGB >> 24));
|
|
}
|
|
void wxGenericColour::Set( const wxString& colourName )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
Set(wxColour(colourName));
|
|
}
|
|
void wxGenericColour::SetRed( unsigned char r )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_r = r;
|
|
}
|
|
void wxGenericColour::SetGreen( unsigned char g )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_g = g;
|
|
}
|
|
void wxGenericColour::SetBlue( unsigned char b )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_b = b;
|
|
}
|
|
void wxGenericColour::SetAlpha( unsigned char a )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic colour"));
|
|
M_GCOLOURDATA->m_a = a;
|
|
}
|
|
|
|
unsigned char wxGenericColour::GetRed() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic colour"));
|
|
return M_GCOLOURDATA->m_r;
|
|
}
|
|
unsigned char wxGenericColour::GetGreen() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic colour"));
|
|
return M_GCOLOURDATA->m_g;
|
|
}
|
|
unsigned char wxGenericColour::GetBlue() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic colour"));
|
|
return M_GCOLOURDATA->m_b;
|
|
}
|
|
unsigned char wxGenericColour::GetAlpha() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic colour"));
|
|
return M_GCOLOURDATA->m_a;
|
|
}
|
|
|
|
bool wxGenericColour::IsSameAs( const wxGenericColour& c ) const
|
|
{
|
|
wxCHECK_MSG(Ok() && c.Ok(), false, wxT("Invalid generic colour"));
|
|
wxGenericColourRefData *cData = (wxGenericColourRefData*)c.GetRefData();
|
|
return (M_GCOLOURDATA->m_r == cData->m_r) && (M_GCOLOURDATA->m_g == cData->m_g) &&
|
|
(M_GCOLOURDATA->m_b == cData->m_b) && (M_GCOLOURDATA->m_a == cData->m_a);
|
|
}
|
|
|
|
bool wxGenericColour::IsSameAs( const wxColour& c ) const
|
|
{
|
|
wxCHECK_MSG(Ok() && c.Ok(), false, wxT("Invalid colour"));
|
|
return (M_GCOLOURDATA->m_r == c.Red()) &&
|
|
(M_GCOLOURDATA->m_g == c.Green()) &&
|
|
(M_GCOLOURDATA->m_b == c.Blue());
|
|
}
|
|
|
|
// This code is assumed to be public domain, originally from Paul Bourke, July 1996
|
|
// http://astronomy.swin.edu.au/~pbourke/colour/colourramp/source1.c
|
|
|
|
wxGenericColour wxGenericColour::GetHotColdColour(double v) const
|
|
{
|
|
wxGenericColour c(255, 255, 255);
|
|
const double vmin = 0.0, vmax = 255.0, dv = vmax - vmin;
|
|
|
|
if (v < vmin) v = vmin;
|
|
if (v > vmax) v = vmax;
|
|
|
|
if (v < (vmin + 0.25 * dv))
|
|
{
|
|
c.SetRed(0);
|
|
c.SetGreen(int(vmax*(4.0 * (v - vmin) / dv) + 0.5));
|
|
}
|
|
else if (v < (vmin + 0.5 * dv))
|
|
{
|
|
c.SetRed(0);
|
|
c.SetBlue(int(vmax*(1.0 + 4.0 * (vmin + 0.25 * dv - v) / dv) + 0.5));
|
|
}
|
|
else if (v < (vmin + 0.75 * dv))
|
|
{
|
|
c.SetRed(int(vmax*(4.0 * (v - vmin - 0.5 * dv) / dv) + 0.5));
|
|
c.SetBlue(0);
|
|
}
|
|
else
|
|
{
|
|
c.SetGreen(int(vmax*(1.0 + 4.0 * (vmin + 0.75 * dv - v) / dv) + 0.5));
|
|
c.SetBlue(0);
|
|
}
|
|
|
|
return c;
|
|
}
|
|
/*
|
|
wxString wxGenericColour::WriteString(const wxString& format) const
|
|
{
|
|
return wxString::Format(format.c_str(), m_r, m_g, m_b, m_a);
|
|
}
|
|
bool wxGenericColour::ReadString(const wxString& str, const wxString& format)
|
|
{
|
|
int r,g,b,a;
|
|
if (4 == wxSscanf(str, format.c_str(), &r, &g, &b, &a))
|
|
{
|
|
m_r = r;
|
|
m_g = g;
|
|
m_b = b;
|
|
m_a = a;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
//----------------------------------------------------------------------------
|
|
// wxGenericPen
|
|
//----------------------------------------------------------------------------
|
|
IMPLEMENT_DYNAMIC_CLASS(wxGenericPen, wxObject)
|
|
|
|
class wxGenericPenRefData : public wxObjectRefData
|
|
{
|
|
public:
|
|
wxGenericPenRefData(int width = 1, int style = wxSOLID,
|
|
int cap = wxCAP_ROUND, int join = wxJOIN_ROUND)
|
|
: wxObjectRefData(), m_width(width), m_style(style),
|
|
m_cap(cap), m_join(join),
|
|
m_dash_count(0), m_dash(NULL) {}
|
|
|
|
wxGenericPenRefData(const wxGenericPenRefData& data) : wxObjectRefData(),
|
|
m_colour(data.m_colour), m_width(data.m_width), m_style(data.m_style),
|
|
m_cap(data.m_cap), m_join(data.m_join),
|
|
m_dash_count(data.m_dash_count), m_dash(NULL)
|
|
{
|
|
if (data.m_dash)
|
|
{
|
|
m_dash = (wxDash*)malloc(m_dash_count*sizeof(wxDash));
|
|
memcpy(m_dash, data.m_dash, m_dash_count*sizeof(wxDash));
|
|
}
|
|
}
|
|
|
|
~wxGenericPenRefData() { if (m_dash) free(m_dash); }
|
|
|
|
wxGenericColour m_colour;
|
|
int m_width;
|
|
int m_style;
|
|
int m_cap;
|
|
int m_join;
|
|
|
|
int m_dash_count; // don't arbitrarily adjust these!
|
|
wxDash *m_dash;
|
|
};
|
|
|
|
#define M_GPENDATA ((wxGenericPenRefData*)m_refData)
|
|
|
|
//----------------------------------------------------------------------------
|
|
wxObjectRefData *wxGenericPen::CreateRefData() const
|
|
{
|
|
return new wxGenericPenRefData;
|
|
}
|
|
wxObjectRefData *wxGenericPen::CloneRefData(const wxObjectRefData *data) const
|
|
{
|
|
return new wxGenericPenRefData(*(const wxGenericPenRefData *)data);
|
|
}
|
|
|
|
void wxGenericPen::Create( const wxGenericPen &pen )
|
|
{
|
|
Ref(pen);
|
|
}
|
|
void wxGenericPen::Create( const wxPen &pen )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericPenRefData;
|
|
Set(pen);
|
|
}
|
|
void wxGenericPen::Create(const wxGenericColour &colour, int width, int style,
|
|
int cap, int join )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericPenRefData(width, style, cap, join);
|
|
M_GPENDATA->m_colour = colour;
|
|
}
|
|
void wxGenericPen::Create(const wxColour &colour, int width, int style,
|
|
int cap, int join )
|
|
{
|
|
Create(wxGenericColour(colour), width, style, cap, join);
|
|
}
|
|
|
|
void wxGenericPen::Set( const wxGenericPen& pen )
|
|
{
|
|
wxCHECK_RET(Ok() && pen.Ok(), wxT("Invalid generic pen"));
|
|
SetColour(pen.GetColour());
|
|
M_GPENDATA->m_width = pen.GetWidth();
|
|
M_GPENDATA->m_style = pen.GetStyle();
|
|
M_GPENDATA->m_cap = pen.GetCap();
|
|
M_GPENDATA->m_join = pen.GetJoin();
|
|
|
|
wxDash* dash;
|
|
int n_dashes = pen.GetDashes(&dash);
|
|
SetDashes(n_dashes, dash);
|
|
}
|
|
void wxGenericPen::Set( const wxPen &pen )
|
|
{
|
|
wxCHECK_RET(Ok() && pen.Ok(), wxT("Invalid generic pen"));
|
|
SetColour(pen.GetColour());
|
|
M_GPENDATA->m_width = pen.GetWidth();
|
|
M_GPENDATA->m_style = pen.GetStyle();
|
|
M_GPENDATA->m_cap = pen.GetCap();
|
|
M_GPENDATA->m_join = pen.GetJoin();
|
|
|
|
wxDash* dash;
|
|
int n_dashes = pen.GetDashes(&dash);
|
|
SetDashes(n_dashes, dash);
|
|
|
|
// or SetDashes(pen.GetDashCount(), pen.GetDash()); not in msw 2.4
|
|
}
|
|
void wxGenericPen::SetColour( const wxGenericColour &colour )
|
|
{
|
|
wxCHECK_RET(Ok() && colour.Ok(), wxT("Invalid generic pen or colour"));
|
|
M_GPENDATA->m_colour = colour;
|
|
}
|
|
void wxGenericPen::SetColour( const wxColour &colour )
|
|
{
|
|
SetColour(wxGenericColour(colour));
|
|
}
|
|
void wxGenericPen::SetColour( int red, int green, int blue, int alpha )
|
|
{
|
|
SetColour(wxGenericColour(red, green, blue, alpha));
|
|
}
|
|
void wxGenericPen::SetCap( int capStyle )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic pen"));
|
|
M_GPENDATA->m_cap = capStyle;
|
|
}
|
|
void wxGenericPen::SetJoin( int joinStyle )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic pen"));
|
|
M_GPENDATA->m_join = joinStyle;
|
|
}
|
|
void wxGenericPen::SetStyle( int style )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic pen"));
|
|
M_GPENDATA->m_style = style;
|
|
}
|
|
void wxGenericPen::SetWidth( int width )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic pen"));
|
|
M_GPENDATA->m_width = width;
|
|
}
|
|
void wxGenericPen::SetDashes( int number_of_dashes, const wxDash *dash )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic pen"));
|
|
wxCHECK_RET(((number_of_dashes == 0) && !dash) ||
|
|
((number_of_dashes > 0) && dash), wxT("Invalid dashes for pen"));
|
|
|
|
// internal double check to see if somebody's messed with this
|
|
//wxCHECK_RET(((M_GPENDATA->m_dash_count == 0) && !M_GPENDATA->m_dash) ||
|
|
// ((M_GPENDATA->m_dash_count != 0) && M_GPENDATA->m_dash), wxT("Invalid internal dashes for pen"));
|
|
|
|
if (M_GPENDATA->m_dash)
|
|
{
|
|
free(M_GPENDATA->m_dash);
|
|
M_GPENDATA->m_dash = NULL;
|
|
M_GPENDATA->m_dash_count = 0;
|
|
}
|
|
|
|
if (!dash)
|
|
return;
|
|
|
|
M_GPENDATA->m_dash_count = number_of_dashes;
|
|
M_GPENDATA->m_dash = (wxDash*)malloc(number_of_dashes*sizeof(wxDash));
|
|
memcpy(M_GPENDATA->m_dash, dash, number_of_dashes*sizeof(wxDash));
|
|
}
|
|
|
|
wxPen wxGenericPen::GetPen() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullPen, wxT("Invalid generic pen"));
|
|
wxPen pen(M_GPENDATA->m_colour.GetColour(), M_GPENDATA->m_width, M_GPENDATA->m_style);
|
|
pen.SetCap(M_GPENDATA->m_cap);
|
|
pen.SetJoin(M_GPENDATA->m_join);
|
|
if (M_GPENDATA->m_dash_count > 0)
|
|
pen.SetDashes(M_GPENDATA->m_dash_count, M_GPENDATA->m_dash);
|
|
|
|
return pen;
|
|
}
|
|
|
|
wxGenericColour wxGenericPen::GetGenericColour() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullGenericColour, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_colour;
|
|
}
|
|
wxColour wxGenericPen::GetColour() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullColour, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_colour.GetColour();
|
|
}
|
|
int wxGenericPen::GetWidth() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 1, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_width;
|
|
}
|
|
int wxGenericPen::GetStyle() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxSOLID, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_style;
|
|
}
|
|
int wxGenericPen::GetCap() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxCAP_ROUND, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_cap;
|
|
}
|
|
int wxGenericPen::GetJoin() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxJOIN_ROUND, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_join;
|
|
}
|
|
int wxGenericPen::GetDashes(wxDash **ptr) const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic pen"));
|
|
*ptr = (wxDash*)M_GPENDATA->m_dash;
|
|
return M_GPENDATA->m_dash_count;
|
|
}
|
|
int wxGenericPen::GetDashCount() const
|
|
{
|
|
wxCHECK_MSG(Ok(), 0, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_dash_count;
|
|
}
|
|
wxDash* wxGenericPen::GetDash() const
|
|
{
|
|
wxCHECK_MSG(Ok(), NULL, wxT("Invalid generic pen"));
|
|
return M_GPENDATA->m_dash;
|
|
}
|
|
|
|
bool wxGenericPen::IsSameAs(const wxGenericPen &pen) const
|
|
{
|
|
wxCHECK_MSG(Ok() && pen.Ok(), false, wxT("Invalid generic pen"));
|
|
wxGenericPenRefData *pData = (wxGenericPenRefData*)pen.GetRefData();
|
|
|
|
if ((M_GPENDATA->m_colour != pData->m_colour) || (M_GPENDATA->m_width != pData->m_width) ||
|
|
(M_GPENDATA->m_style != pData->m_style) || (M_GPENDATA->m_cap != pData->m_cap) ||
|
|
(M_GPENDATA->m_join != pData->m_join) || (M_GPENDATA->m_dash_count != pen.GetDashCount()))
|
|
return false;
|
|
|
|
if (M_GPENDATA->m_dash_count > 0)
|
|
return memcmp(M_GPENDATA->m_dash, pen.GetDash(), M_GPENDATA->m_dash_count*sizeof(wxDash)) == 0;
|
|
|
|
return true;
|
|
}
|
|
bool wxGenericPen::IsSameAs(const wxPen &pen) const
|
|
{
|
|
wxCHECK_MSG(Ok() && pen.Ok(), false, wxT("Invalid generic pen"));
|
|
wxGenericPen gp(pen);
|
|
gp.GetGenericColour().SetAlpha(M_GPENDATA->m_colour.GetAlpha());
|
|
return IsSameAs(gp);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
wxString wxGenericPen::WriteString() const
|
|
{
|
|
wxString str;
|
|
str.Printf(wxT("%s,%d,%d,%d,%d,%d"), m_colour.WriteString().c_str(),
|
|
m_width, m_style, m_cap, m_join,
|
|
m_dash_count);
|
|
|
|
for (int i = 0; i < m_dash_count; i++)
|
|
str += wxString::Format(wxT(",%d"), m_dash[i]);
|
|
|
|
return str;
|
|
}
|
|
|
|
bool wxGenericPen::ReadString(const wxString& str)
|
|
{
|
|
wxArrayString tokens = wxStringTokenize(str, wxT(", "), wxTOKEN_DEFAULT);
|
|
size_t n, count = tokens.GetCount();
|
|
|
|
if (count < 9u)
|
|
return false;
|
|
|
|
long val;
|
|
|
|
for (n = 0; n < count; n++)
|
|
{
|
|
if (!tokens[n].ToLong(&val))
|
|
return false;
|
|
|
|
values.Add(int(val));
|
|
}
|
|
|
|
m_colour.Set(values[0], values[1], values[2], values[3]);
|
|
|
|
size_t num_dashes = values[8];
|
|
|
|
if (num_dashes != count - 9)
|
|
return false;
|
|
|
|
if (num_dashes > 0)
|
|
{
|
|
wxDash *dash = new wxDash[num_dashes];
|
|
for (n = 0; n < num_dashes; n++)
|
|
dash[n] = (wxDash)values[n];
|
|
|
|
SetDashes(num_dashes, dash);
|
|
delete dash;
|
|
}
|
|
|
|
|
|
m_width = values[4];
|
|
m_style = values[5];
|
|
m_cap = values[6];
|
|
m_join = values[7];
|
|
//m_dash_count = values[8];
|
|
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// wxGenericBrush
|
|
//----------------------------------------------------------------------------
|
|
IMPLEMENT_DYNAMIC_CLASS(wxGenericBrush, wxObject)
|
|
|
|
class wxGenericBrushRefData : public wxObjectRefData
|
|
{
|
|
public:
|
|
wxGenericBrushRefData(const wxGenericColour& c = wxNullGenericColour,
|
|
int style = wxSOLID) : wxObjectRefData(),
|
|
m_colour(c), m_style(style) {}
|
|
|
|
wxGenericBrushRefData(const wxGenericBrushRefData& data) : wxObjectRefData(),
|
|
m_colour(data.m_colour), m_style(data.m_style), m_stipple(data.m_stipple) {}
|
|
|
|
~wxGenericBrushRefData() { }
|
|
|
|
wxGenericColour m_colour;
|
|
int m_style;
|
|
wxBitmap m_stipple;
|
|
};
|
|
|
|
#define M_GBRUSHDATA ((wxGenericBrushRefData*)m_refData)
|
|
|
|
//----------------------------------------------------------------------------
|
|
wxObjectRefData *wxGenericBrush::CreateRefData() const
|
|
{
|
|
return new wxGenericBrushRefData;
|
|
}
|
|
wxObjectRefData *wxGenericBrush::CloneRefData(const wxObjectRefData *data) const
|
|
{
|
|
return new wxGenericBrushRefData(*(const wxGenericBrushRefData *)data);
|
|
}
|
|
|
|
void wxGenericBrush::Create( const wxGenericBrush &brush )
|
|
{
|
|
Ref(brush);
|
|
}
|
|
void wxGenericBrush::Create( const wxBrush &brush )
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericBrushRefData;
|
|
Set(brush);
|
|
}
|
|
void wxGenericBrush::Create(const wxGenericColour &colour, int style)
|
|
{
|
|
UnRef();
|
|
m_refData = new wxGenericBrushRefData(colour, style);
|
|
}
|
|
void wxGenericBrush::Create(const wxColour &colour, int style)
|
|
{
|
|
Create(wxGenericColour(colour), style);
|
|
}
|
|
void wxGenericBrush::Create( const wxBitmap &stipple )
|
|
{
|
|
UnRef();
|
|
wxCHECK_RET(stipple.Ok(), wxT("Invalid bitmap in wxGenericBrush::Create"));
|
|
|
|
int style = stipple.GetMask() ? wxSTIPPLE_MASK_OPAQUE : wxSTIPPLE;
|
|
m_refData = new wxGenericBrushRefData(wxNullGenericColour, style);
|
|
M_GBRUSHDATA->m_stipple = stipple;
|
|
}
|
|
|
|
void wxGenericBrush::Set( const wxGenericBrush& brush )
|
|
{
|
|
wxCHECK_RET(Ok() && brush.Ok(), wxT("Invalid generic brush"));
|
|
SetColour(brush.GetColour());
|
|
M_GBRUSHDATA->m_style = brush.GetStyle();
|
|
wxBitmap* stipple = brush.GetStipple();
|
|
if (stipple && stipple->Ok())
|
|
M_GBRUSHDATA->m_stipple = *stipple;
|
|
}
|
|
void wxGenericBrush::Set( const wxBrush &brush )
|
|
{
|
|
wxCHECK_RET(Ok() && brush.Ok(), wxT("Invalid generic brush"));
|
|
SetColour(brush.GetColour());
|
|
M_GBRUSHDATA->m_style = brush.GetStyle();
|
|
wxBitmap* stipple = brush.GetStipple();
|
|
if (stipple && stipple->Ok())
|
|
M_GBRUSHDATA->m_stipple = *stipple;
|
|
}
|
|
void wxGenericBrush::SetColour( const wxGenericColour &colour )
|
|
{
|
|
wxCHECK_RET(Ok() && colour.Ok(), wxT("Invalid generic brush or colour"));
|
|
M_GBRUSHDATA->m_colour = colour;
|
|
}
|
|
void wxGenericBrush::SetColour( const wxColour &colour )
|
|
{
|
|
SetColour(wxGenericColour(colour));
|
|
}
|
|
void wxGenericBrush::SetColour( int red, int green, int blue, int alpha )
|
|
{
|
|
SetColour(wxGenericColour(red, green, blue, alpha));
|
|
}
|
|
void wxGenericBrush::SetStyle( int style )
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic brush"));
|
|
M_GBRUSHDATA->m_style = style;
|
|
}
|
|
void wxGenericBrush::SetStipple(const wxBitmap& stipple)
|
|
{
|
|
wxCHECK_RET(Ok(), wxT("Invalid generic brush"));
|
|
M_GBRUSHDATA->m_stipple = stipple;
|
|
M_GBRUSHDATA->m_style = stipple.GetMask() ? wxSTIPPLE_MASK_OPAQUE : wxSTIPPLE;
|
|
|
|
}
|
|
|
|
wxBrush wxGenericBrush::GetBrush() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullBrush, wxT("Invalid generic brush"));
|
|
if (M_GBRUSHDATA->m_stipple.Ok())
|
|
return wxBrush(M_GBRUSHDATA->m_stipple);
|
|
|
|
return wxBrush(M_GBRUSHDATA->m_colour.GetColour(), M_GBRUSHDATA->m_style);
|
|
}
|
|
|
|
wxGenericColour wxGenericBrush::GetGenericColour() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullGenericColour, wxT("Invalid generic brush"));
|
|
return M_GBRUSHDATA->m_colour;
|
|
}
|
|
wxColour wxGenericBrush::GetColour() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxNullColour, wxT("Invalid generic brush"));
|
|
return M_GBRUSHDATA->m_colour.GetColour();
|
|
}
|
|
int wxGenericBrush::GetStyle() const
|
|
{
|
|
wxCHECK_MSG(Ok(), wxSOLID, wxT("Invalid generic brush"));
|
|
return M_GBRUSHDATA->m_style;
|
|
}
|
|
wxBitmap* wxGenericBrush::GetStipple() const
|
|
{
|
|
wxCHECK_MSG(Ok(), NULL, wxT("Invalid generic brush"));
|
|
return &M_GBRUSHDATA->m_stipple;
|
|
}
|
|
|
|
bool wxGenericBrush::IsSameAs(const wxGenericBrush& brush) const
|
|
{
|
|
wxCHECK_MSG(Ok() && brush.Ok(), 1, wxT("Invalid generic brush"));
|
|
wxGenericBrushRefData *bData = (wxGenericBrushRefData*)brush.GetRefData();
|
|
return (M_GBRUSHDATA->m_colour == bData->m_colour) &&
|
|
(M_GBRUSHDATA->m_style == bData->m_style) &&
|
|
(M_GBRUSHDATA->m_stipple == bData->m_stipple);
|
|
}
|
|
bool wxGenericBrush::IsSameAs(const wxBrush& brush) const
|
|
{
|
|
wxCHECK_MSG(Ok() && brush.Ok(), 1, wxT("Invalid generic brush"));
|
|
wxGenericBrush gB(brush);
|
|
gB.GetGenericColour().SetAlpha(M_GBRUSHDATA->m_colour.GetAlpha());
|
|
return IsSameAs(gB);
|
|
}
|