]> git.saurik.com Git - wxWidgets.git/blob - src/common/gdicmn.cpp
projects / wxWidgets.git / blob
? search:


cc9045fbe0e101826ec1c948a8edfb4b97986b11
[wxWidgets.git] / src / common / gdicmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/gdicmn.cpp
3 // Purpose: Common GDI classes
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #include "wx/gdicmn.h"
20 #include "wx/gdiobj.h"
21
22 #ifndef WX_PRECOMP
23 #include "wx/log.h"
24 #include "wx/pen.h"
25 #include "wx/brush.h"
26 #include "wx/palette.h"
27 #include "wx/icon.h"
28 #include "wx/iconbndl.h"
29 #include "wx/cursor.h"
30 #include "wx/settings.h"
31 #include "wx/bitmap.h"
32 #include "wx/colour.h"
33 #include "wx/font.h"
34 #include "wx/math.h"
35 #endif
36
37
38 IMPLEMENT_ABSTRACT_CLASS(wxGDIObject, wxObject)
39
40
41 WXDLLIMPEXP_DATA_CORE(wxBrushList*) wxTheBrushList;
42 WXDLLIMPEXP_DATA_CORE(wxFontList*) wxTheFontList;
43 WXDLLIMPEXP_DATA_CORE(wxPenList*) wxThePenList;
44
45 WXDLLIMPEXP_DATA_CORE(wxColourDatabase*) wxTheColourDatabase;
46
47 WXDLLIMPEXP_DATA_CORE(wxBitmap) wxNullBitmap;
48 WXDLLIMPEXP_DATA_CORE(wxBrush) wxNullBrush;
49 WXDLLIMPEXP_DATA_CORE(wxColour) wxNullColour;
50 WXDLLIMPEXP_DATA_CORE(wxCursor) wxNullCursor;
51 WXDLLIMPEXP_DATA_CORE(wxFont) wxNullFont;
52 WXDLLIMPEXP_DATA_CORE(wxIcon) wxNullIcon;
53 WXDLLIMPEXP_DATA_CORE(wxPen) wxNullPen;
54 #if wxUSE_PALETTE
55 WXDLLIMPEXP_DATA_CORE(wxPalette) wxNullPalette;
56 #endif
57 WXDLLIMPEXP_DATA_CORE(wxIconBundle) wxNullIconBundle;
58
59 const wxSize wxDefaultSize(wxDefaultCoord, wxDefaultCoord);
60 const wxPoint wxDefaultPosition(wxDefaultCoord, wxDefaultCoord);
61
62 #include "wx/listimpl.cpp"
63 WX_DEFINE_LIST(wxPointList)
64
65
66 #if wxUSE_EXTENDED_RTTI
67
68 // wxPoint
69
70 template<> void wxStringReadValue(const wxString &s , wxPoint &data )
71 {
72 wxSscanf(s, wxT("%d,%d"), &data.x , &data.y ) ;
73 }
74
75 template<> void wxStringWriteValue(wxString &s , const wxPoint &data )
76 {
77 s = wxString::Format(wxT("%d,%d"), data.x , data.y ) ;
78 }
79
80 wxCUSTOM_TYPE_INFO(wxPoint, wxToStringConverter<wxPoint> , wxFromStringConverter<wxPoint>)
81
82 template<> void wxStringReadValue(const wxString &s , wxSize &data )
83 {
84 wxSscanf(s, wxT("%d,%d"), &data.x , &data.y ) ;
85 }
86
87 template<> void wxStringWriteValue(wxString &s , const wxSize &data )
88 {
89 s = wxString::Format(wxT("%d,%d"), data.x , data.y ) ;
90 }
91
92 wxCUSTOM_TYPE_INFO(wxSize, wxToStringConverter<wxSize> , wxFromStringConverter<wxSize>)
93
94 #endif
95
96 wxRect::wxRect(const wxPoint& point1, const wxPoint& point2)
97 {
98 x = point1.x;
99 y = point1.y;
100 width = point2.x - point1.x;
101 height = point2.y - point1.y;
102
103 if (width < 0)
104 {
105 width = -width;
106 x = point2.x;
107 }
108 width++;
109
110 if (height < 0)
111 {
112 height = -height;
113 y = point2.y;
114 }
115 height++;
116 }
117
118 wxRect& wxRect::Union(const wxRect& rect)
119 {
120 // ignore empty rectangles: union with an empty rectangle shouldn't extend
121 // this one to (0, 0)
122 if ( !width || !height )
123 {
124 *this = rect;
125 }
126 else if ( rect.width && rect.height )
127 {
128 int x1 = wxMin(x, rect.x);
129 int y1 = wxMin(y, rect.y);
130 int y2 = wxMax(y + height, rect.height + rect.y);
131 int x2 = wxMax(x + width, rect.width + rect.x);
132
133 x = x1;
134 y = y1;
135 width = x2 - x1;
136 height = y2 - y1;
137 }
138 //else: we're not empty and rect is empty
139
140 return *this;
141 }
142
143 wxRect& wxRect::Inflate(wxCoord dx, wxCoord dy)
144 {
145 if (-2*dx>width)
146 {
147 // Don't allow deflate to eat more width than we have,
148 // a well-defined rectangle cannot have negative width.
149 x+=width/2;
150 width=0;
151 }
152 else
153 {
154 // The inflate is valid.
155 x-=dx;
156 width+=2*dx;
157 }
158
159 if (-2*dy>height)
160 {
161 // Don't allow deflate to eat more height than we have,
162 // a well-defined rectangle cannot have negative height.
163 y+=height/2;
164 height=0;
165 }
166 else
167 {
168 // The inflate is valid.
169 y-=dy;
170 height+=2*dy;
171 }
172
173 return *this;
174 }
175
176 bool wxRect::Contains(int cx, int cy) const
177 {
178 return ( (cx >= x) && (cy >= y)
179 && ((cy - y) < height)
180 && ((cx - x) < width)
181 );
182 }
183
184 bool wxRect::Contains(const wxRect& rect) const
185 {
186 return Contains(rect.GetTopLeft()) && Contains(rect.GetBottomRight());
187 }
188
189 wxRect& wxRect::Intersect(const wxRect& rect)
190 {
191 int x2 = GetRight(),
192 y2 = GetBottom();
193
194 if ( x < rect.x )
195 x = rect.x;
196 if ( y < rect.y )
197 y = rect.y;
198 if ( x2 > rect.GetRight() )
199 x2 = rect.GetRight();
200 if ( y2 > rect.GetBottom() )
201 y2 = rect.GetBottom();
202
203 width = x2 - x + 1;
204 height = y2 - y + 1;
205
206 if ( width <= 0 || height <= 0 )
207 {
208 width =
209 height = 0;
210 }
211
212 return *this;
213 }
214
215 bool wxRect::Intersects(const wxRect& rect) const
216 {
217 wxRect r = Intersect(rect);
218
219 // if there is no intersection, both width and height are 0
220 return r.width != 0;
221 }
222
223 wxRect& wxRect::operator+=(const wxRect& rect)
224 {
225 *this = *this + rect;
226 return *this;
227 }
228
229
230 wxRect& wxRect::operator*=(const wxRect& rect)
231 {
232 *this = *this * rect;
233 return *this;
234 }
235
236
237 wxRect operator+(const wxRect& r1, const wxRect& r2)
238 {
239 int x1 = wxMin(r1.x, r2.x);
240 int y1 = wxMin(r1.y, r2.y);
241 int y2 = wxMax(r1.y+r1.height, r2.height+r2.y);
242 int x2 = wxMax(r1.x+r1.width, r2.width+r2.x);
243 return wxRect(x1, y1, x2-x1, y2-y1);
244 }
245
246 wxRect operator*(const wxRect& r1, const wxRect& r2)
247 {
248 int x1 = wxMax(r1.x, r2.x);
249 int y1 = wxMax(r1.y, r2.y);
250 int y2 = wxMin(r1.y+r1.height, r2.height+r2.y);
251 int x2 = wxMin(r1.x+r1.width, r2.width+r2.x);
252 return wxRect(x1, y1, x2-x1, y2-y1);
253 }
254
255 wxRealPoint::wxRealPoint(const wxPoint& pt)
256 : x(pt.x), y(pt.y)
257 {
258 }
259
260 // ============================================================================
261 // wxColourDatabase
262 // ============================================================================
263
264 // ----------------------------------------------------------------------------
265 // wxColourDatabase ctor/dtor
266 // ----------------------------------------------------------------------------
267
268 wxColourDatabase::wxColourDatabase ()
269 {
270 // will be created on demand in Initialize()
271 m_map = NULL;
272 }
273
274 wxColourDatabase::~wxColourDatabase ()
275 {
276 if ( m_map )
277 {
278 WX_CLEAR_HASH_MAP(wxStringToColourHashMap, *m_map);
279
280 delete m_map;
281 }
282
283 #ifdef __WXPM__
284 delete [] m_palTable;
285 #endif
286 }
287
288 // Colour database stuff
289 void wxColourDatabase::Initialize()
290 {
291 if ( m_map )
292 {
293 // already initialized
294 return;
295 }
296
297 m_map = new wxStringToColourHashMap;
298
299 static const struct wxColourDesc
300 {
301 const wxChar *name;
302 unsigned char r,g,b;
303 }
304 wxColourTable[] =
305 {
306 {wxT("AQUAMARINE"),112, 219, 147},
307 {wxT("BLACK"),0, 0, 0},
308 {wxT("BLUE"), 0, 0, 255},
309 {wxT("BLUE VIOLET"), 159, 95, 159},
310 {wxT("BROWN"), 165, 42, 42},
311 {wxT("CADET BLUE"), 95, 159, 159},
312 {wxT("CORAL"), 255, 127, 0},
313 {wxT("CORNFLOWER BLUE"), 66, 66, 111},
314 {wxT("CYAN"), 0, 255, 255},
315 {wxT("DARK GREY"), 47, 47, 47}, // ?
316
317 {wxT("DARK GREEN"), 47, 79, 47},
318 {wxT("DARK OLIVE GREEN"), 79, 79, 47},
319 {wxT("DARK ORCHID"), 153, 50, 204},
320 {wxT("DARK SLATE BLUE"), 107, 35, 142},
321 {wxT("DARK SLATE GREY"), 47, 79, 79},
322 {wxT("DARK TURQUOISE"), 112, 147, 219},
323 {wxT("DIM GREY"), 84, 84, 84},
324 {wxT("FIREBRICK"), 142, 35, 35},
325 {wxT("FOREST GREEN"), 35, 142, 35},
326 {wxT("GOLD"), 204, 127, 50},
327 {wxT("GOLDENROD"), 219, 219, 112},
328 {wxT("GREY"), 128, 128, 128},
329 {wxT("GREEN"), 0, 255, 0},
330 {wxT("GREEN YELLOW"), 147, 219, 112},
331 {wxT("INDIAN RED"), 79, 47, 47},
332 {wxT("KHAKI"), 159, 159, 95},
333 {wxT("LIGHT BLUE"), 191, 216, 216},
334 {wxT("LIGHT GREY"), 192, 192, 192},
335 {wxT("LIGHT STEEL BLUE"), 143, 143, 188},
336 {wxT("LIME GREEN"), 50, 204, 50},
337 {wxT("LIGHT MAGENTA"), 255, 0, 255},
338 {wxT("MAGENTA"), 255, 0, 255},
339 {wxT("MAROON"), 142, 35, 107},
340 {wxT("MEDIUM AQUAMARINE"), 50, 204, 153},
341 {wxT("MEDIUM GREY"), 100, 100, 100},
342 {wxT("MEDIUM BLUE"), 50, 50, 204},
343 {wxT("MEDIUM FOREST GREEN"), 107, 142, 35},
344 {wxT("MEDIUM GOLDENROD"), 234, 234, 173},
345 {wxT("MEDIUM ORCHID"), 147, 112, 219},
346 {wxT("MEDIUM SEA GREEN"), 66, 111, 66},
347 {wxT("MEDIUM SLATE BLUE"), 127, 0, 255},
348 {wxT("MEDIUM SPRING GREEN"), 127, 255, 0},
349 {wxT("MEDIUM TURQUOISE"), 112, 219, 219},
350 {wxT("MEDIUM VIOLET RED"), 219, 112, 147},
351 {wxT("MIDNIGHT BLUE"), 47, 47, 79},
352 {wxT("NAVY"), 35, 35, 142},
353 {wxT("ORANGE"), 204, 50, 50},
354 {wxT("ORANGE RED"), 255, 0, 127},
355 {wxT("ORCHID"), 219, 112, 219},
356 {wxT("PALE GREEN"), 143, 188, 143},
357 {wxT("PINK"), 255, 192, 203},
358 {wxT("PLUM"), 234, 173, 234},
359 {wxT("PURPLE"), 176, 0, 255},
360 {wxT("RED"), 255, 0, 0},
361 {wxT("SALMON"), 111, 66, 66},
362 {wxT("SEA GREEN"), 35, 142, 107},
363 {wxT("SIENNA"), 142, 107, 35},
364 {wxT("SKY BLUE"), 50, 153, 204},
365 {wxT("SLATE BLUE"), 0, 127, 255},
366 {wxT("SPRING GREEN"), 0, 255, 127},
367 {wxT("STEEL BLUE"), 35, 107, 142},
368 {wxT("TAN"), 219, 147, 112},
369 {wxT("THISTLE"), 216, 191, 216},
370 {wxT("TURQUOISE"), 173, 234, 234},
371 {wxT("VIOLET"), 79, 47, 79},
372 {wxT("VIOLET RED"), 204, 50, 153},
373 {wxT("WHEAT"), 216, 216, 191},
374 {wxT("WHITE"), 255, 255, 255},
375 {wxT("YELLOW"), 255, 255, 0},
376 {wxT("YELLOW GREEN"), 153, 204, 50}
377 };
378
379 size_t n;
380
381 for ( n = 0; n < WXSIZEOF(wxColourTable); n++ )
382 {
383 const wxColourDesc& cc = wxColourTable[n];
384 (*m_map)[cc.name] = new wxColour(cc.r, cc.g, cc.b);
385 }
386
387 #ifdef __WXPM__
388 m_palTable = new long[n];
389 for ( n = 0; n < WXSIZEOF(wxColourTable); n++ )
390 {
391 const wxColourDesc& cc = wxColourTable[n];
392 m_palTable[n] = OS2RGB(cc.r,cc.g,cc.b);
393 }
394 m_nSize = n;
395 #endif
396 }
397
398 // ----------------------------------------------------------------------------
399 // wxColourDatabase operations
400 // ----------------------------------------------------------------------------
401
402 void wxColourDatabase::AddColour(const wxString& name, const wxColour& colour)
403 {
404 Initialize();
405
406 // canonicalize the colour names before using them as keys: they should be
407 // in upper case
408 wxString colName = name;
409 colName.MakeUpper();
410
411 // ... and we also allow both grey/gray
412 wxString colNameAlt = colName;
413 if ( !colNameAlt.Replace(wxT("GRAY"), wxT("GREY")) )
414 {
415 // but in this case it is not necessary so avoid extra search below
416 colNameAlt.clear();
417 }
418
419 wxStringToColourHashMap::iterator it = m_map->find(colName);
420 if ( it == m_map->end() && !colNameAlt.empty() )
421 it = m_map->find(colNameAlt);
422 if ( it != m_map->end() )
423 {
424 *(it->second) = colour;
425 }
426 else // new colour
427 {
428 (*m_map)[colName] = new wxColour(colour);
429 }
430 }
431
432 wxColour wxColourDatabase::Find(const wxString& colour) const
433 {
434 wxColourDatabase * const self = wxConstCast(this, wxColourDatabase);
435 self->Initialize();
436
437 // make the comparaison case insensitive and also match both grey and gray
438 wxString colName = colour;
439 colName.MakeUpper();
440 wxString colNameAlt = colName;
441 if ( !colNameAlt.Replace(wxT("GRAY"), wxT("GREY")) )
442 colNameAlt.clear();
443
444 wxStringToColourHashMap::iterator it = m_map->find(colName);
445 if ( it == m_map->end() && !colNameAlt.empty() )
446 it = m_map->find(colNameAlt);
447 if ( it != m_map->end() )
448 return *(it->second);
449
450 // we did not find any result in existing colours:
451 // we won't use wxString -> wxColour conversion because the
452 // wxColour::Set(const wxString &) function which does that conversion
453 // internally uses this function (wxColourDatabase::Find) and we want
454 // to avoid infinite recursion !
455 return wxNullColour;
456 }
457
458 wxString wxColourDatabase::FindName(const wxColour& colour) const
459 {
460 wxColourDatabase * const self = wxConstCast(this, wxColourDatabase);
461 self->Initialize();
462
463 typedef wxStringToColourHashMap::iterator iterator;
464
465 for ( iterator it = m_map->begin(), en = m_map->end(); it != en; ++it )
466 {
467 if ( *(it->second) == colour )
468 return it->first;
469 }
470
471 return wxEmptyString;
472 }
473
474 // ----------------------------------------------------------------------------
475 // deprecated wxColourDatabase methods
476 // ----------------------------------------------------------------------------
477
478 #if WXWIN_COMPATIBILITY_2_6
479 wxColour *wxColourDatabase::FindColour(const wxString& name)
480 {
481 // This function is deprecated, use Find() instead.
482 // Formerly this function sometimes would return a deletable pointer and
483 // sometimes a non-deletable one (when returning a colour from the database).
484 // Trying to delete the latter anyway results in problems, so probably
485 // nobody ever freed the pointers. Currently it always returns a new
486 // instance, which means there will be memory leaks.
487 wxLogDebug(wxT("wxColourDataBase::FindColour():")
488 wxT(" Please use wxColourDataBase::Find() instead"));
489
490 // using a static variable here is not the most elegant solution but unless
491 // we want to make wxStringToColourHashMap public (i.e. move it to the
492 // header) so that we could have a member function returning
493 // wxStringToColourHashMap::iterator, there is really no good way to do it
494 // otherwise
495 //
496 // and knowing that this function is going to disappear in the next release
497 // anyhow I don't want to waste time on this
498
499 static wxColour s_col;
500
501 s_col = Find(name);
502 if ( !s_col.Ok() )
503 return NULL;
504
505 return new wxColour(s_col);
506 }
507 #endif // WXWIN_COMPATIBILITY_2_6
508
509 // ============================================================================
510 // stock objects
511 // ============================================================================
512
513 static wxStockGDI gs_wxStockGDI_instance;
514 wxStockGDI* wxStockGDI::ms_instance = &gs_wxStockGDI_instance;
515 wxObject* wxStockGDI::ms_stockObject[ITEMCOUNT];
516
517 wxStockGDI::wxStockGDI()
518 {
519 }
520
521 wxStockGDI::~wxStockGDI()
522 {
523 }
524
525 void wxStockGDI::DeleteAll()
526 {
527 for (unsigned i = 0; i < ITEMCOUNT; i++)
528 {
529 wxDELETE(ms_stockObject[i]);
530 }
531 }
532
533 const wxBrush* wxStockGDI::GetBrush(Item item)
534 {
535 wxBrush* brush = static_cast<wxBrush*>(ms_stockObject[item]);
536 if (brush == NULL)
537 {
538 switch (item)
539 {
540 case BRUSH_BLACK:
541 brush = new wxBrush(*GetColour(COLOUR_BLACK), wxBRUSHSTYLE_SOLID);
542 break;
543 case BRUSH_BLUE:
544 brush = new wxBrush(*GetColour(COLOUR_BLUE), wxBRUSHSTYLE_SOLID);
545 break;
546 case BRUSH_CYAN:
547 brush = new wxBrush(*GetColour(COLOUR_CYAN), wxBRUSHSTYLE_SOLID);
548 break;
549 case BRUSH_GREEN:
550 brush = new wxBrush(*GetColour(COLOUR_GREEN), wxBRUSHSTYLE_SOLID);
551 break;
552 case BRUSH_YELLOW:
553 brush = new wxBrush(*GetColour(COLOUR_YELLOW), wxBRUSHSTYLE_SOLID);
554 break;
555 case BRUSH_GREY:
556 brush = new wxBrush(wxColour(wxT("GREY")), wxBRUSHSTYLE_SOLID);
557 break;
558 case BRUSH_LIGHTGREY:
559 brush = new wxBrush(*GetColour(COLOUR_LIGHTGREY), wxBRUSHSTYLE_SOLID);
560 break;
561 case BRUSH_MEDIUMGREY:
562 brush = new wxBrush(wxColour(wxT("MEDIUM GREY")), wxBRUSHSTYLE_SOLID);
563 break;
564 case BRUSH_RED:
565 brush = new wxBrush(*GetColour(COLOUR_RED), wxBRUSHSTYLE_SOLID);
566 break;
567 case BRUSH_TRANSPARENT:
568 brush = new wxBrush(*GetColour(COLOUR_BLACK), wxBRUSHSTYLE_TRANSPARENT);
569 break;
570 case BRUSH_WHITE:
571 brush = new wxBrush(*GetColour(COLOUR_WHITE), wxBRUSHSTYLE_SOLID);
572 break;
573 default:
574 wxFAIL;
575 }
576 ms_stockObject[item] = brush;
577 }
578 return brush;
579 }
580
581 const wxColour* wxStockGDI::GetColour(Item item)
582 {
583 wxColour* colour = static_cast<wxColour*>(ms_stockObject[item]);
584 if (colour == NULL)
585 {
586 switch (item)
587 {
588 case COLOUR_BLACK:
589 colour = new wxColour(0, 0, 0);
590 break;
591 case COLOUR_BLUE:
592 colour = new wxColour(0, 0, 255);
593 break;
594 case COLOUR_CYAN:
595 colour = new wxColour(wxT("CYAN"));
596 break;
597 case COLOUR_GREEN:
598 colour = new wxColour(0, 255, 0);
599 break;
600 case COLOUR_YELLOW:
601 colour = new wxColour(255, 255, 0);
602 break;
603 case COLOUR_LIGHTGREY:
604 colour = new wxColour(wxT("LIGHT GREY"));
605 break;
606 case COLOUR_RED:
607 colour = new wxColour(255, 0, 0);
608 break;
609 case COLOUR_WHITE:
610 colour = new wxColour(255, 255, 255);
611 break;
612 default:
613 wxFAIL;
614 }
615 ms_stockObject[item] = colour;
616 }
617 return colour;
618 }
619
620 const wxCursor* wxStockGDI::GetCursor(Item item)
621 {
622 wxCursor* cursor = static_cast<wxCursor*>(ms_stockObject[item]);
623 if (cursor == NULL)
624 {
625 switch (item)
626 {
627 case CURSOR_CROSS:
628 cursor = new wxCursor(wxCURSOR_CROSS);
629 break;
630 case CURSOR_HOURGLASS:
631 cursor = new wxCursor(wxCURSOR_WAIT);
632 break;
633 case CURSOR_STANDARD:
634 cursor = new wxCursor(wxCURSOR_ARROW);
635 break;
636 default:
637 wxFAIL;
638 }
639 ms_stockObject[item] = cursor;
640 }
641 return cursor;
642 }
643
644 const wxFont* wxStockGDI::GetFont(Item item)
645 {
646 wxFont* font = static_cast<wxFont*>(ms_stockObject[item]);
647 if (font == NULL)
648 {
649 switch (item)
650 {
651 case FONT_ITALIC:
652 font = new wxFont(GetFont(FONT_NORMAL)->GetPointSize(), wxROMAN, wxITALIC, wxNORMAL);
653 break;
654 case FONT_NORMAL:
655 font = new wxFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
656 break;
657 case FONT_SMALL:
658 font = new wxFont(GetFont(FONT_NORMAL)->GetPointSize() - 2, wxSWISS, wxNORMAL, wxNORMAL);
659 break;
660 case FONT_SWISS:
661 font = new wxFont(GetFont(FONT_NORMAL)->GetPointSize(), wxSWISS, wxNORMAL, wxNORMAL);
662 break;
663 default:
664 wxFAIL;
665 }
666 ms_stockObject[item] = font;
667 }
668 return font;
669 }
670
671 const wxPen* wxStockGDI::GetPen(Item item)
672 {
673 wxPen* pen = static_cast<wxPen*>(ms_stockObject[item]);
674 if (pen == NULL)
675 {
676 switch (item)
677 {
678 case PEN_BLACK:
679 pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_SOLID);
680 break;
681 case PEN_BLACKDASHED:
682 pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_SHORT_DASH);
683 break;
684 case PEN_BLUE:
685 pen = new wxPen(*GetColour(COLOUR_BLUE), 1, wxPENSTYLE_SOLID);
686 break;
687 case PEN_CYAN:
688 pen = new wxPen(*GetColour(COLOUR_CYAN), 1, wxPENSTYLE_SOLID);
689 break;
690 case PEN_GREEN:
691 pen = new wxPen(*GetColour(COLOUR_GREEN), 1, wxPENSTYLE_SOLID);
692 break;
693 case PEN_YELLOW:
694 pen = new wxPen(*GetColour(COLOUR_YELLOW), 1, wxPENSTYLE_SOLID);
695 break;
696 case PEN_GREY:
697 pen = new wxPen(wxColour(wxT("GREY")), 1, wxPENSTYLE_SOLID);
698 break;
699 case PEN_LIGHTGREY:
700 pen = new wxPen(*GetColour(COLOUR_LIGHTGREY), 1, wxPENSTYLE_SOLID);
701 break;
702 case PEN_MEDIUMGREY:
703 pen = new wxPen(wxColour(wxT("MEDIUM GREY")), 1, wxPENSTYLE_SOLID);
704 break;
705 case PEN_RED:
706 pen = new wxPen(*GetColour(COLOUR_RED), 1, wxPENSTYLE_SOLID);
707 break;
708 case PEN_TRANSPARENT:
709 pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_TRANSPARENT);
710 break;
711 case PEN_WHITE:
712 pen = new wxPen(*GetColour(COLOUR_WHITE), 1, wxPENSTYLE_SOLID);
713 break;
714 default:
715 wxFAIL;
716 }
717 ms_stockObject[item] = pen;
718 }
719 return pen;
720 }
721
722 void wxInitializeStockLists()
723 {
724 wxTheColourDatabase = new wxColourDatabase;
725
726 wxTheBrushList = new wxBrushList;
727 wxThePenList = new wxPenList;
728 wxTheFontList = new wxFontList;
729 }
730
731 void wxDeleteStockLists()
732 {
733 wxDELETE(wxTheBrushList);
734 wxDELETE(wxThePenList);
735 wxDELETE(wxTheFontList);
736
737 // wxTheColourDatabase is cleaned up by wxAppBase::CleanUp()
738 }
739
740 // ============================================================================
741 // wxTheXXXList stuff (semi-obsolete)
742 // ============================================================================
743
744 wxGDIObjListBase::wxGDIObjListBase()
745 {
746 }
747
748 wxGDIObjListBase::~wxGDIObjListBase()
749 {
750 for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
751 {
752 delete static_cast<wxObject*>(node->GetData());
753 }
754 }
755
756 wxPen *wxPenList::FindOrCreatePen (const wxColour& colour, int width, wxPenStyle style)
757 {
758 for ( wxList::compatibility_iterator node = list.GetFirst();
759 node;
760 node = node->GetNext() )
761 {
762 wxPen * const pen = (wxPen *) node->GetData();
763 if ( pen->GetWidth () == width &&
764 pen->GetStyle () == style &&
765 pen->GetColour() == colour )
766 return pen;
767 }
768
769 wxPen* pen = NULL;
770 wxPen penTmp(colour, width, style);
771 if (penTmp.Ok())
772 {
773 pen = new wxPen(penTmp);
774 list.Append(pen);
775 }
776
777 return pen;
778 }
779
780 wxBrush *wxBrushList::FindOrCreateBrush (const wxColour& colour, wxBrushStyle style)
781 {
782 for ( wxList::compatibility_iterator node = list.GetFirst();
783 node;
784 node = node->GetNext() )
785 {
786 wxBrush * const brush = (wxBrush *) node->GetData ();
787 if ( brush->GetStyle() == style && brush->GetColour() == colour )
788 return brush;
789 }
790
791 wxBrush* brush = NULL;
792 wxBrush brushTmp(colour, style);
793 if (brushTmp.Ok())
794 {
795 brush = new wxBrush(brushTmp);
796 list.Append(brush);
797 }
798
799 return brush;
800 }
801
802 wxFont *wxFontList::FindOrCreateFont(int pointSize,
803 wxFontFamily family,
804 wxFontStyle style,
805 wxFontWeight weight,
806 bool underline,
807 const wxString& facename,
808 wxFontEncoding encoding)
809 {
810 wxFont *font;
811 wxList::compatibility_iterator node;
812 for (node = list.GetFirst(); node; node = node->GetNext())
813 {
814 font = (wxFont *)node->GetData();
815 if (
816 font->GetPointSize () == pointSize &&
817 font->GetStyle () == style &&
818 font->GetWeight () == weight &&
819 font->GetUnderlined () == underline )
820 {
821 wxFontFamily fontFamily = (wxFontFamily)font->GetFamily();
822
823 #if defined(__WXGTK__)
824 // under GTK the default family is wxSWISS, so looking for a font
825 // with wxDEFAULT family should return a wxSWISS one instead of
826 // creating a new one
827 bool same = (fontFamily == family) ||
828 (fontFamily == wxFONTFAMILY_SWISS && family == wxFONTFAMILY_DEFAULT);
829 #else // !GTK
830 // VZ: but why elsewhere do we require an exact match? mystery...
831 bool same = fontFamily == family;
832 #endif // GTK/!GTK
833
834 // empty facename matches anything at all: this is bad because
835 // depending on which fonts are already created, we might get back
836 // a different font if we create it with empty facename, but it is
837 // still better than never matching anything in the cache at all
838 // in this case
839 if ( same && !facename.empty() )
840 {
841 const wxString& fontFace = font->GetFaceName();
842
843 // empty facename matches everything
844 same = !fontFace || fontFace == facename;
845 }
846
847 if ( same && (encoding != wxFONTENCODING_DEFAULT) )
848 {
849 // have to match the encoding too
850 same = font->GetEncoding() == encoding;
851 }
852
853 if ( same )
854 {
855 return font;
856 }
857 }
858 }
859
860 // font not found, create the new one
861 font = NULL;
862 wxFont fontTmp(pointSize, family, style, weight, underline, facename, encoding);
863 if (fontTmp.Ok())
864 {
865 font = new wxFont(fontTmp);
866 list.Append(font);
867 }
868
869 return font;
870 }
871
872 #if WXWIN_COMPATIBILITY_2_6
873 void wxBrushList::AddBrush(wxBrush*) { }
874 void wxBrushList::RemoveBrush(wxBrush*) { }
875 void wxFontList::AddFont(wxFont*) { }
876 void wxFontList::RemoveFont(wxFont*) { }
877 void wxPenList::AddPen(wxPen*) { }
878 void wxPenList::RemovePen(wxPen*) { }
879 #endif
880
881 wxSize wxGetDisplaySize()
882 {
883 int x, y;
884 wxDisplaySize(& x, & y);
885 return wxSize(x, y);
886 }
887
888 wxRect wxGetClientDisplayRect()
889 {
890 int x, y, width, height;
891 wxClientDisplayRect(&x, &y, &width, &height); // call plat-specific version
892 return wxRect(x, y, width, height);
893 }
894
895 wxSize wxGetDisplaySizeMM()
896 {
897 int x, y;
898 wxDisplaySizeMM(& x, & y);
899 return wxSize(x, y);
900 }
901
902 wxSize wxGetDisplayPPI()
903 {
904 const wxSize pixels = wxGetDisplaySize();
905 const wxSize mm = wxGetDisplaySizeMM();
906
907 return wxSize((int)((pixels.x * inches2mm) / mm.x),
908 (int)((pixels.y * inches2mm) / mm.y));
909 }
910
911 wxResourceCache::~wxResourceCache ()
912 {
913 wxList::compatibility_iterator node = GetFirst ();
914 while (node) {
915 wxObject *item = (wxObject *)node->GetData();
916 delete item;
917
918 node = node->GetNext ();
919 }
920 }
wxWidgets (Impactor)