]> git.saurik.com Git - wxWidgets.git/blob - src/univ/themes/metal.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / univ / themes / metal.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/univ/themes/metal.cpp
3 // Purpose: wxUniversal theme implementing Win32-like LNF
4 // Author: Vadim Zeitlin, Robert Roebling
5 // Modified by:
6 // Created: 06.08.00
7 // RCS-ID: $Id$
8 // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/univ/theme.h"
28
29 #if wxUSE_THEME_METAL
30
31 #ifndef WX_PRECOMP
32 #include "wx/timer.h"
33 #include "wx/intl.h"
34 #include "wx/dc.h"
35 #include "wx/window.h"
36
37 #include "wx/dcmemory.h"
38
39 #include "wx/button.h"
40 #include "wx/listbox.h"
41 #include "wx/checklst.h"
42 #include "wx/combobox.h"
43 #include "wx/scrolbar.h"
44 #include "wx/slider.h"
45 #include "wx/textctrl.h"
46 #include "wx/toolbar.h"
47
48 #include "wx/menu.h"
49 #include "wx/settings.h"
50 #include "wx/toplevel.h"
51 #endif // WX_PRECOMP
52
53 #include "wx/notebook.h"
54 #include "wx/spinbutt.h"
55 #include "wx/artprov.h"
56
57 #include "wx/univ/scrtimer.h"
58 #include "wx/univ/renderer.h"
59 #include "wx/univ/inpcons.h"
60 #include "wx/univ/inphand.h"
61 #include "wx/univ/colschem.h"
62
63 // ----------------------------------------------------------------------------
64 // wxMetalRenderer: draw the GUI elements in Metal style
65 // ----------------------------------------------------------------------------
66
67 class wxMetalRenderer : public wxDelegateRenderer
68 {
69 // FIXME cut'n'paste from Win32
70 enum wxArrowDirection
71 {
72 Arrow_Left,
73 Arrow_Right,
74 Arrow_Up,
75 Arrow_Down,
76 Arrow_Max
77 };
78
79 enum wxArrowStyle
80 {
81 Arrow_Normal,
82 Arrow_Disabled,
83 Arrow_Pressed,
84 Arrow_Inverted,
85 Arrow_InvertedDisabled,
86 Arrow_StateMax
87 };
88 public:
89 wxMetalRenderer(wxRenderer *renderer, wxColourScheme* scheme);
90
91 virtual void DrawButtonSurface(wxDC& dc,
92 const wxColour& WXUNUSED(col),
93 const wxRect& rect,
94 int WXUNUSED(flags))
95 { DrawMetal(dc, rect); }
96
97 virtual void DrawScrollbarThumb(wxDC& dc,
98 wxOrientation orient,
99 const wxRect& rect,
100 int flags);
101
102 virtual void DrawScrollbarShaft(wxDC& dc,
103 wxOrientation orient,
104 const wxRect& rectBar,
105 int flags);
106
107 virtual void GetComboBitmaps(wxBitmap *bmpNormal,
108 wxBitmap *bmpFocus,
109 wxBitmap *bmpPressed,
110 wxBitmap *bmpDisabled);
111
112 virtual void DrawArrow(wxDC& dc,
113 wxDirection dir,
114 const wxRect& rect,
115 int flags = 0);
116 protected:
117 void DrawArrowButton(wxDC& dc,
118 const wxRect& rectAll,
119 wxArrowDirection arrowDir,
120 wxArrowStyle arrowStyle);
121
122 void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
123
124 void DrawShadedRect(wxDC& dc, wxRect *rect,
125 const wxPen& pen1, const wxPen& pen2);
126
127 void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = false);
128
129 void DrawArrow(wxDC& dc, const wxRect& rect,
130 wxArrowDirection arrowDir, wxArrowStyle arrowStyle);
131
132 void DrawMetal(wxDC &dc, const wxRect &rect );
133 private:
134 wxPen m_penBlack,
135 m_penDarkGrey,
136 m_penLightGrey,
137 m_penHighlight;
138
139 wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
140 };
141
142 // ----------------------------------------------------------------------------
143 // wxMetalTheme
144 // ----------------------------------------------------------------------------
145
146 class wxMetalTheme : public wxDelegateTheme
147 {
148 public:
149 wxMetalTheme() : wxDelegateTheme(wxT("win32")), m_renderer(NULL) {}
150 ~wxMetalTheme() { delete m_renderer; }
151
152 protected:
153 virtual wxRenderer *GetRenderer()
154 {
155 if ( !m_renderer )
156 {
157 m_renderer = new wxMetalRenderer(m_theme->GetRenderer(),
158 GetColourScheme());
159 }
160
161 return m_renderer;
162 }
163
164 wxRenderer *m_renderer;
165
166 WX_DECLARE_THEME(Metal)
167 };
168
169 WX_IMPLEMENT_THEME(wxMetalTheme, Metal, wxTRANSLATE("Metal theme"));
170
171
172 // ============================================================================
173 // implementation
174 // ============================================================================
175
176 // ----------------------------------------------------------------------------
177 // wxMetalRenderer
178 // ----------------------------------------------------------------------------
179
180 wxMetalRenderer::wxMetalRenderer(wxRenderer *renderer, wxColourScheme *scheme)
181 : wxDelegateRenderer(renderer)
182 {
183 // init colours and pens
184 m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
185 m_penDarkGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT), 0, wxSOLID);
186 m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
187 m_penHighlight = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT), 0, wxSOLID);
188
189 // init the arrow bitmaps
190 static const size_t ARROW_WIDTH = 7;
191 static const size_t ARROW_LENGTH = 4;
192
193 wxMask *mask;
194 wxMemoryDC dcNormal,
195 dcDisabled,
196 dcInverse;
197 for ( size_t n = 0; n < Arrow_Max; n++ )
198 {
199 bool isVertical = n > Arrow_Right;
200 int w, h;
201 if ( isVertical )
202 {
203 w = ARROW_WIDTH;
204 h = ARROW_LENGTH;
205 }
206 else
207 {
208 h = ARROW_WIDTH;
209 w = ARROW_LENGTH;
210 }
211
212 // disabled arrow is larger because of the shadow
213 m_bmpArrows[Arrow_Normal][n].Create(w, h);
214 m_bmpArrows[Arrow_Disabled][n].Create(w + 1, h + 1);
215
216 dcNormal.SelectObject(m_bmpArrows[Arrow_Normal][n]);
217 dcDisabled.SelectObject(m_bmpArrows[Arrow_Disabled][n]);
218
219 dcNormal.SetBackground(*wxWHITE_BRUSH);
220 dcDisabled.SetBackground(*wxWHITE_BRUSH);
221 dcNormal.Clear();
222 dcDisabled.Clear();
223
224 dcNormal.SetPen(m_penBlack);
225 dcDisabled.SetPen(m_penDarkGrey);
226
227 // calculate the position of the point of the arrow
228 wxCoord x1, y1;
229 if ( isVertical )
230 {
231 x1 = (ARROW_WIDTH - 1)/2;
232 y1 = n == Arrow_Up ? 0 : ARROW_LENGTH - 1;
233 }
234 else // horizontal
235 {
236 x1 = n == Arrow_Left ? 0 : ARROW_LENGTH - 1;
237 y1 = (ARROW_WIDTH - 1)/2;
238 }
239
240 wxCoord x2 = x1,
241 y2 = y1;
242
243 if ( isVertical )
244 x2++;
245 else
246 y2++;
247
248 for ( size_t i = 0; i < ARROW_LENGTH; i++ )
249 {
250 dcNormal.DrawLine(x1, y1, x2, y2);
251 dcDisabled.DrawLine(x1, y1, x2, y2);
252
253 if ( isVertical )
254 {
255 x1--;
256 x2++;
257
258 if ( n == Arrow_Up )
259 {
260 y1++;
261 y2++;
262 }
263 else // down arrow
264 {
265 y1--;
266 y2--;
267 }
268 }
269 else // left or right arrow
270 {
271 y1--;
272 y2++;
273
274 if ( n == Arrow_Left )
275 {
276 x1++;
277 x2++;
278 }
279 else
280 {
281 x1--;
282 x2--;
283 }
284 }
285 }
286
287 // draw the shadow for the disabled one
288 dcDisabled.SetPen(m_penHighlight);
289 switch ( n )
290 {
291 case Arrow_Left:
292 y1 += 2;
293 dcDisabled.DrawLine(x1, y1, x2, y2);
294 break;
295
296 case Arrow_Right:
297 x1 = ARROW_LENGTH - 1;
298 y1 = (ARROW_WIDTH - 1)/2 + 1;
299 x2 = 0;
300 y2 = ARROW_WIDTH;
301 dcDisabled.DrawLine(x1, y1, x2, y2);
302 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
303 break;
304
305 case Arrow_Up:
306 x1 += 2;
307 dcDisabled.DrawLine(x1, y1, x2, y2);
308 break;
309
310 case Arrow_Down:
311 x1 = ARROW_WIDTH - 1;
312 y1 = 1;
313 x2 = (ARROW_WIDTH - 1)/2;
314 y2 = ARROW_LENGTH;
315 dcDisabled.DrawLine(x1, y1, x2, y2);
316 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
317 break;
318
319 }
320
321 // create the inverted bitmap but only for the right arrow as we only
322 // use it for the menus
323 if ( n == Arrow_Right )
324 {
325 m_bmpArrows[Arrow_Inverted][n].Create(w, h);
326 dcInverse.SelectObject(m_bmpArrows[Arrow_Inverted][n]);
327 dcInverse.Clear();
328 dcInverse.Blit(0, 0, w, h,
329 &dcNormal, 0, 0,
330 wxXOR);
331 dcInverse.SelectObject(wxNullBitmap);
332
333 mask = new wxMask(m_bmpArrows[Arrow_Inverted][n], *wxBLACK);
334 m_bmpArrows[Arrow_Inverted][n].SetMask(mask);
335
336 m_bmpArrows[Arrow_InvertedDisabled][n].Create(w, h);
337 dcInverse.SelectObject(m_bmpArrows[Arrow_InvertedDisabled][n]);
338 dcInverse.Clear();
339 dcInverse.Blit(0, 0, w, h,
340 &dcDisabled, 0, 0,
341 wxXOR);
342 dcInverse.SelectObject(wxNullBitmap);
343
344 mask = new wxMask(m_bmpArrows[Arrow_InvertedDisabled][n], *wxBLACK);
345 m_bmpArrows[Arrow_InvertedDisabled][n].SetMask(mask);
346 }
347
348 dcNormal.SelectObject(wxNullBitmap);
349 dcDisabled.SelectObject(wxNullBitmap);
350
351 mask = new wxMask(m_bmpArrows[Arrow_Normal][n], *wxWHITE);
352 m_bmpArrows[Arrow_Normal][n].SetMask(mask);
353 mask = new wxMask(m_bmpArrows[Arrow_Disabled][n], *wxWHITE);
354 m_bmpArrows[Arrow_Disabled][n].SetMask(mask);
355
356 m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
357 }
358 }
359
360 void wxMetalRenderer::DrawScrollbarThumb(wxDC& dc,
361 wxOrientation WXUNUSED(orient),
362 const wxRect& rect,
363 int WXUNUSED(flags))
364 {
365 // we don't use the flags, the thumb never changes appearance
366 wxRect rectThumb = rect;
367 DrawArrowBorder(dc, &rectThumb);
368 DrawMetal(dc, rectThumb);
369 }
370
371 void wxMetalRenderer::DrawScrollbarShaft(wxDC& dc,
372 wxOrientation WXUNUSED(orient),
373 const wxRect& rectBar,
374 int WXUNUSED(flags))
375 {
376 DrawMetal(dc, rectBar);
377 }
378
379 void wxMetalRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
380 wxBitmap * WXUNUSED(bmpFocus),
381 wxBitmap *bmpPressed,
382 wxBitmap *bmpDisabled)
383 {
384 static const wxCoord widthCombo = 16;
385 static const wxCoord heightCombo = 17;
386
387 wxMemoryDC dcMem;
388
389 if ( bmpNormal )
390 {
391 bmpNormal->Create(widthCombo, heightCombo);
392 dcMem.SelectObject(*bmpNormal);
393 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
394 Arrow_Down, Arrow_Normal);
395 }
396
397 if ( bmpPressed )
398 {
399 bmpPressed->Create(widthCombo, heightCombo);
400 dcMem.SelectObject(*bmpPressed);
401 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
402 Arrow_Down, Arrow_Pressed);
403 }
404
405 if ( bmpDisabled )
406 {
407 bmpDisabled->Create(widthCombo, heightCombo);
408 dcMem.SelectObject(*bmpDisabled);
409 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
410 Arrow_Down, Arrow_Disabled);
411 }
412 }
413
414 void wxMetalRenderer::DrawArrow(wxDC& dc,
415 wxDirection dir,
416 const wxRect& rect,
417 int flags)
418 {
419 // get the bitmap for this arrow
420 wxArrowDirection arrowDir;
421 switch ( dir )
422 {
423 case wxLEFT: arrowDir = Arrow_Left; break;
424 case wxRIGHT: arrowDir = Arrow_Right; break;
425 case wxUP: arrowDir = Arrow_Up; break;
426 case wxDOWN: arrowDir = Arrow_Down; break;
427
428 default:
429 wxFAIL_MSG(wxT("unknown arrow direction"));
430 return;
431 }
432
433 wxArrowStyle arrowStyle;
434 if ( flags & wxCONTROL_PRESSED )
435 {
436 // can't be pressed and disabled
437 arrowStyle = Arrow_Pressed;
438 }
439 else
440 {
441 arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
442 }
443
444 DrawArrowButton(dc, rect, arrowDir, arrowStyle);
445 }
446
447 //
448 // protected functions
449 //
450
451 void wxMetalRenderer::DrawArrowButton(wxDC& dc,
452 const wxRect& rectAll,
453 wxArrowDirection arrowDir,
454 wxArrowStyle arrowStyle)
455 {
456 wxRect rect = rectAll;
457 DrawMetal( dc, rect );
458 DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
459 DrawArrow(dc, rect, arrowDir, arrowStyle);
460 }
461
462 void wxMetalRenderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
463 {
464 // draw
465 dc.SetPen(pen);
466 dc.SetBrush(*wxTRANSPARENT_BRUSH);
467 dc.DrawRectangle(*rect);
468
469 // adjust the rect
470 rect->Inflate(-1);
471 }
472
473 void wxMetalRenderer::DrawShadedRect(wxDC& dc, wxRect *rect,
474 const wxPen& pen1, const wxPen& pen2)
475 {
476 // draw the rectangle
477 dc.SetPen(pen1);
478 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
479 rect->GetLeft(), rect->GetBottom());
480 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
481 rect->GetRight(), rect->GetTop());
482 dc.SetPen(pen2);
483 dc.DrawLine(rect->GetRight(), rect->GetTop(),
484 rect->GetRight(), rect->GetBottom());
485 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
486 rect->GetRight() + 1, rect->GetBottom());
487
488 // adjust the rect
489 rect->Inflate(-1);
490 }
491
492 void wxMetalRenderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
493 {
494 if ( isPressed )
495 {
496 DrawRect(dc, rect, m_penDarkGrey);
497
498 // the arrow is usually drawn inside border of width 2 and is offset by
499 // another pixel in both directions when it's pressed - as the border
500 // in this case is more narrow as well, we have to adjust rect like
501 // this:
502 rect->Inflate(-1);
503 rect->x++;
504 rect->y++;
505 }
506 else
507 {
508 DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
509 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
510 }
511 }
512
513 void wxMetalRenderer::DrawArrow(wxDC& dc,
514 const wxRect& rect,
515 wxArrowDirection arrowDir,
516 wxArrowStyle arrowStyle)
517 {
518 const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
519
520 // under Windows the arrows always have the same size so just centre it in
521 // the provided rectangle
522 wxCoord x = rect.x + (rect.width - bmp.GetWidth()) / 2,
523 y = rect.y + (rect.height - bmp.GetHeight()) / 2;
524
525 // Windows does it like this...
526 if ( arrowDir == Arrow_Left )
527 x--;
528
529 // draw it
530 dc.DrawBitmap(bmp, x, y, true /* use mask */);
531 }
532
533 // ----------------------------------------------------------------------------
534 // metal gradient
535 // ----------------------------------------------------------------------------
536
537 void wxMetalRenderer::DrawMetal(wxDC &dc, const wxRect &rect )
538 {
539 dc.SetPen(*wxTRANSPARENT_PEN);
540 for (int y = rect.y; y < rect.height+rect.y; y++)
541 {
542 unsigned char intens = (unsigned char)(230 + 80 * (rect.y-y) / rect.height);
543 dc.SetBrush( wxBrush( wxColour(intens,intens,intens), wxSOLID ) );
544 dc.DrawRectangle( rect.x, y, rect.width, 1 );
545 }
546 }
547
548 #endif // wxUSE_THEME_METAL