src/mgl/brush.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/mgl/brush.cpp
   3 // Purpose:
   4 // Author:      Vaclav Slavik
   5 // Id:          $Id$
   6 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #include "wx/brush.h"
  18 #include "wx/mgl/private.h"
  19 #include "wx/mgl/dcmemory.h"
  20
  21
  22 // ---------------------------------------------------------------------------
  23 // helper functions
  24 // ---------------------------------------------------------------------------
  25
  26 // This function converts wxBitmap into pixpattern24_t representation
  27 // (used by wxBrush and wxPen)
  28
  29 void wxBitmapToPixPattern(const wxBitmap& bitmap,
  30                           pixpattern24_t *pix, pattern_t *mask)
  31 {
  32     wxMemoryDC mem;
  33     MGLDevCtx *dc;
  34     int x, y;
  35
  36     if ( pix != NULL )
  37     {
  38         mem.SelectObject(bitmap);
  39         dc = mem.GetMGLDC();
  40         wxCurrentDCSwitcher curDC(dc);
  41         dc->beginPixel();
  42         for (y = 0; y < 8; y++)
  43             for (x = 0; x < 8; x++)
  44                 dc->unpackColorFast(dc->getPixelFast(x, y),
  45                                     pix->p[y][x][2],
  46                                     pix->p[y][x][1],
  47                                     pix->p[y][x][0]);
  48         dc->endPixel();
  49     }
  50
  51     if ( mask && bitmap.GetMask() )
  52     {
  53         mem.SelectObject(*bitmap.GetMask()->GetBitmap());
  54         dc = mem.GetMGLDC();
  55         wxCurrentDCSwitcher curDC(dc);
  56         dc->beginPixel();
  57         for (y = 0; y < 8; y++)
  58         {
  59             mask->p[y] = 0;
  60             for (x = 0; x < 8; x++)
  61                 if ( dc->getPixelFast(x, y) != 0 )
  62                     mask->p[y] = (uchar)(mask->p[y] | (1 << (7 - x)));
  63         }
  64         dc->endPixel();
  65     }
  66 }
  67
  68
  69 //-----------------------------------------------------------------------------
  70 // wxBrush
  71 //-----------------------------------------------------------------------------
  72
  73 class wxBrushRefData: public wxObjectRefData
  74 {
  75 public:
  76     wxBrushRefData();
  77     wxBrushRefData(const wxBrushRefData& data);
  78
  79     int            m_style;
  80     wxColour       m_colour;
  81     wxBitmap       m_stipple;
  82     pixpattern24_t m_pixPattern;
  83     pattern_t      m_maskPattern;
  84 };
  85
  86 wxBrushRefData::wxBrushRefData()
  87 {
  88     m_style = 0;
  89
  90     int x, y, c;
  91     for (y = 0; y < 8; y++)
  92         for (x = 0; x < 8; x++)
  93             for (c = 0; c < 3; c++)
  94                 m_pixPattern.p[y][x][c] = 0;
  95     for (y = 0; y < 8; y++)
  96         m_maskPattern.p[y] = 0;
  97 }
  98
  99 wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
 100 {
 101     m_style = data.m_style;
 102     m_stipple = data.m_stipple;
 103     m_colour = data.m_colour;
 104
 105     int x, y, c;
 106     for (y = 0; y < 8; y++)
 107         for (x = 0; x < 8; x++)
 108             for (c = 0; c < 3; c++)
 109                 m_pixPattern.p[y][x][c] = data.m_pixPattern.p[y][x][c];
 110     for (y = 0; y < 8; y++)
 111         m_maskPattern.p[y] = data.m_maskPattern.p[y];
 112 }
 113
 114 //-----------------------------------------------------------------------------
 115
 116 #define M_BRUSHDATA ((wxBrushRefData *)m_refData)
 117
 118 IMPLEMENT_DYNAMIC_CLASS(wxBrush,wxGDIObject)
 119
 120 wxBrush::wxBrush(const wxColour &colour, int style)
 121 {
 122     m_refData = new wxBrushRefData();
 123     M_BRUSHDATA->m_style = style;
 124     M_BRUSHDATA->m_colour = colour;
 125 }
 126
 127 wxBrush::wxBrush(const wxBitmap &stippleBitmap)
 128 {
 129     wxCHECK_RET( stippleBitmap.Ok(), _T("invalid bitmap") );
 130     wxCHECK_RET( stippleBitmap.GetWidth() == 8 && stippleBitmap.GetHeight() == 8,
 131                   _T("stipple bitmap must be 8x8") );
 132
 133     m_refData = new wxBrushRefData();
 134     M_BRUSHDATA->m_colour = *wxBLACK;
 135
 136     M_BRUSHDATA->m_stipple = stippleBitmap;
 137     wxBitmapToPixPattern(stippleBitmap, &(M_BRUSHDATA->m_pixPattern),
 138                                         &(M_BRUSHDATA->m_maskPattern));
 139
 140     if (M_BRUSHDATA->m_stipple.GetMask())
 141         M_BRUSHDATA->m_style = wxSTIPPLE_MASK_OPAQUE;
 142     else
 143         M_BRUSHDATA->m_style = wxSTIPPLE;
 144 }
 145
 146 wxBrush::wxBrush(const wxBrush &brush)
 147 {
 148     Ref(brush);
 149 }
 150
 151 wxBrush& wxBrush::operator = (const wxBrush& brush)
 152 {
 153     if (*this == brush) return (*this);
 154     Ref(brush);
 155     return *this;
 156 }
 157
 158 bool wxBrush::operator == (const wxBrush& brush) const
 159 {
 160     return m_refData == brush.m_refData;
 161 }
 162
 163 bool wxBrush::operator != (const wxBrush& brush) const
 164 {
 165     return m_refData != brush.m_refData;
 166 }
 167
 168 bool wxBrush::Ok() const
 169 {
 170     return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
 171 }
 172
 173 int wxBrush::GetStyle() const
 174 {
 175     if (m_refData == NULL)
 176     {
 177         wxFAIL_MSG( wxT("invalid brush") );
 178         return 0;
 179     }
 180
 181     return M_BRUSHDATA->m_style;
 182 }
 183
 184 wxColour &wxBrush::GetColour() const
 185 {
 186     if (m_refData == NULL)
 187     {
 188         wxFAIL_MSG( wxT("invalid brush") );
 189         return wxNullColour;
 190     }
 191
 192     return M_BRUSHDATA->m_colour;
 193 }
 194
 195 wxBitmap *wxBrush::GetStipple() const
 196 {
 197     if (m_refData == NULL)
 198     {
 199         wxFAIL_MSG( wxT("invalid brush") );
 200         return &wxNullBitmap;
 201     }
 202
 203     return &M_BRUSHDATA->m_stipple;
 204 }
 205
 206 void* wxBrush::GetMaskPattern() const
 207 {
 208     wxCHECK_MSG( Ok(), NULL, wxT("invalid brush") );
 209
 210     return (void*)&(M_BRUSHDATA->m_maskPattern);
 211 }
 212
 213 void* wxBrush::GetPixPattern() const
 214 {
 215     wxCHECK_MSG( Ok(), NULL, wxT("invalid brush") );
 216
 217     return (void*)&(M_BRUSHDATA->m_pixPattern);
 218 }
 219
 220 void wxBrush::SetColour(const wxColour& col)
 221 {
 222     AllocExclusive();
 223     M_BRUSHDATA->m_colour = col;
 224 }
 225
 226 void wxBrush::SetColour(unsigned char r, unsigned char g, unsigned char b)
 227 {
 228     AllocExclusive();
 229     M_BRUSHDATA->m_colour.Set(r, g, b);
 230 }
 231
 232 void wxBrush::SetStyle( int style )
 233 {
 234     AllocExclusive();
 235     M_BRUSHDATA->m_style = style;
 236 }
 237
 238 void wxBrush::SetStipple(const wxBitmap& stipple)
 239 {
 240     AllocExclusive();
 241
 242     wxCHECK_RET( stipple.Ok(), _T("invalid bitmap") );
 243     wxCHECK_RET( stipple.GetWidth() == 8 && stipple.GetHeight() == 8,
 244                   _T("stipple bitmap must be 8x8") );
 245
 246     M_BRUSHDATA->m_stipple = stipple;
 247     wxBitmapToPixPattern(stipple, &(M_BRUSHDATA->m_pixPattern),
 248                                   &(M_BRUSHDATA->m_maskPattern));
 249
 250     if (M_BRUSHDATA->m_stipple.GetMask())
 251         M_BRUSHDATA->m_style = wxSTIPPLE_MASK_OPAQUE;
 252     else
 253         M_BRUSHDATA->m_style = wxSTIPPLE;
 254 }
 255
 256 wxObjectRefData *wxBrush::CreateRefData() const
 257 {
 258     return new wxBrushRefData;
 259 }
 260
 261 wxObjectRefData *wxBrush::CloneRefData(const wxObjectRefData *data) const
 262 {
 263     return new wxBrushRefData(*(wxBrushRefData *)data);
 264 }