]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/univ/themes/mono.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Correct a print format specifier mismatch in wxFileConfig::Parse().
[wxWidgets.git] / src / univ / themes / mono.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: src/univ/themes/mono.cpp
3// Purpose: wxUniversal theme for monochrome displays
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 2006-08-27
7// RCS-ID: $Id$
8// Copyright: (c) 2006 REA Elektronik GmbH
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_MONO
30
31#ifndef WX_PRECOMP
32 #include "wx/window.h"
33 #include "wx/dc.h"
34#endif // WX_PRECOMP
35
36#include "wx/artprov.h"
37#include "wx/univ/stdrend.h"
38#include "wx/univ/inphand.h"
39#include "wx/univ/colschem.h"
40
41class wxMonoColourScheme;
42
43#define wxMONO_BG_COL (*wxWHITE)
44#define wxMONO_FG_COL (*wxBLACK)
45
46// ----------------------------------------------------------------------------
47// wxMonoRenderer: draw the GUI elements in simplest possible way
48// ----------------------------------------------------------------------------
49
50// Warning: many of the methods here are not implemented, the code won't work
51// if any but a few wxUSE_XXXs are on
52class wxMonoRenderer : public wxStdRenderer
53{
54public:
55 wxMonoRenderer(const wxColourScheme *scheme);
56
57 virtual void DrawLabel(wxDC& dc,
58 const wxString& label,
59 const wxRect& rect,
60 int flags = 0,
61 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
62 int indexAccel = -1,
63 wxRect *rectBounds = NULL);
64 virtual void DrawButtonLabel(wxDC& dc,
65 const wxString& label,
66 const wxBitmap& image,
67 const wxRect& rect,
68 int flags = 0,
69 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
70 int indexAccel = -1,
71 wxRect *rectBounds = NULL);
72
73 virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0);
74
75 virtual void DrawButtonBorder(wxDC& dc,
76 const wxRect& rect,
77 int flags = 0,
78 wxRect *rectIn = NULL);
79
80 virtual void DrawHorizontalLine(wxDC& dc,
81 wxCoord y, wxCoord x1, wxCoord x2);
82
83 virtual void DrawVerticalLine(wxDC& dc,
84 wxCoord x, wxCoord y1, wxCoord y2);
85
86 virtual void DrawArrow(wxDC& dc,
87 wxDirection dir,
88 const wxRect& rect,
89 int flags = 0);
90 virtual void DrawScrollbarThumb(wxDC& dc,
91 wxOrientation orient,
92 const wxRect& rect,
93 int flags = 0);
94 virtual void DrawScrollbarShaft(wxDC& dc,
95 wxOrientation orient,
96 const wxRect& rect,
97 int flags = 0);
98
99#if wxUSE_TOOLBAR
100 virtual void DrawToolBarButton(wxDC& dc,
101 const wxString& label,
102 const wxBitmap& bitmap,
103 const wxRect& rect,
104 int flags = 0,
105 long style = 0,
106 int tbarStyle = 0);
107#endif // wxUSE_TOOLBAR
108
109#if wxUSE_NOTEBOOK
110 virtual void DrawTab(wxDC& dc,
111 const wxRect& rect,
112 wxDirection dir,
113 const wxString& label,
114 const wxBitmap& bitmap = wxNullBitmap,
115 int flags = 0,
116 int indexAccel = -1);
117#endif // wxUSE_NOTEBOOK
118
119#if wxUSE_SLIDER
120 virtual void DrawSliderShaft(wxDC& dc,
121 const wxRect& rect,
122 int lenThumb,
123 wxOrientation orient,
124 int flags = 0,
125 long style = 0,
126 wxRect *rectShaft = NULL);
127
128 virtual void DrawSliderThumb(wxDC& dc,
129 const wxRect& rect,
130 wxOrientation orient,
131 int flags = 0,
132 long style = 0);
133
134 virtual void DrawSliderTicks(wxDC& dc,
135 const wxRect& rect,
136 int lenThumb,
137 wxOrientation orient,
138 int start,
139 int end,
140 int step = 1,
141 int flags = 0,
142 long style = 0);
143#endif // wxUSE_SLIDER
144
145#if wxUSE_MENUS
146 virtual void DrawMenuBarItem(wxDC& dc,
147 const wxRect& rect,
148 const wxString& label,
149 int flags = 0,
150 int indexAccel = -1);
151
152 virtual void DrawMenuItem(wxDC& dc,
153 wxCoord y,
154 const wxMenuGeometryInfo& geometryInfo,
155 const wxString& label,
156 const wxString& accel,
157 const wxBitmap& bitmap = wxNullBitmap,
158 int flags = 0,
159 int indexAccel = -1);
160
161 virtual void DrawMenuSeparator(wxDC& dc,
162 wxCoord y,
163 const wxMenuGeometryInfo& geomInfo);
164#endif // wxUSE_MENUS
165
166#if wxUSE_COMBOBOX
167 virtual void GetComboBitmaps(wxBitmap *bmpNormal,
168 wxBitmap *bmpFocus,
169 wxBitmap *bmpPressed,
170 wxBitmap *bmpDisabled);
171#endif // wxUSE_COMBOBOX
172
173
174 virtual wxRect GetBorderDimensions(wxBorder border) const;
175
176#if wxUSE_SCROLLBAR
177 virtual wxSize GetScrollbarArrowSize() const { return GetStdBmpSize(); }
178#endif // wxUSE_SCROLLBAR
179
180 virtual wxSize GetCheckBitmapSize() const { return GetStdBmpSize(); }
181 virtual wxSize GetRadioBitmapSize() const { return GetStdBmpSize(); }
182
183#if wxUSE_TOOLBAR
184 virtual wxSize GetToolBarButtonSize(wxCoord *separator) const;
185
186 virtual wxSize GetToolBarMargin() const;
187#endif // wxUSE_TOOLBAR
188
189#if wxUSE_NOTEBOOK
190 virtual wxSize GetTabIndent() const;
191
192 virtual wxSize GetTabPadding() const;
193#endif // wxUSE_NOTEBOOK
194
195#if wxUSE_SLIDER
196 virtual wxCoord GetSliderDim() const;
197
198 virtual wxCoord GetSliderTickLen() const;
199
200 virtual wxRect GetSliderShaftRect(const wxRect& rect,
201 int lenThumb,
202 wxOrientation orient,
203 long style = 0) const;
204
205 virtual wxSize GetSliderThumbSize(const wxRect& rect,
206 int lenThumb,
207 wxOrientation orient) const;
208#endif // wxUSE_SLIDER
209
210 virtual wxSize GetProgressBarStep() const;
211
212#if wxUSE_MENUS
213 virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
214
215 virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
216 const wxMenu& menu) const;
217#endif // wxUSE_MENUS
218
219#if wxUSE_STATUSBAR
220 virtual wxCoord GetStatusBarBorderBetweenFields() const;
221
222 virtual wxSize GetStatusBarFieldMargins() const;
223#endif // wxUSE_STATUSBAR
224
225protected:
226 // override base class border drawing routines: we always draw just a
227 // single simple border
228 void DrawSimpleBorder(wxDC& dc, wxRect *rect)
229 { DrawRect(dc, rect, m_penFg); }
230
231 virtual void DrawRaisedBorder(wxDC& dc, wxRect *rect)
232 { DrawSimpleBorder(dc, rect); }
233 virtual void DrawSunkenBorder(wxDC& dc, wxRect *rect)
234 { DrawSimpleBorder(dc, rect); }
235 virtual void DrawAntiSunkenBorder(wxDC& dc, wxRect *rect)
236 { DrawSimpleBorder(dc, rect); }
237 virtual void DrawBoxBorder(wxDC& dc, wxRect *rect)
238 { DrawSimpleBorder(dc, rect); }
239 virtual void DrawStaticBorder(wxDC& dc, wxRect *rect)
240 { DrawSimpleBorder(dc, rect); }
241 virtual void DrawExtraBorder(wxDC& WXUNUSED(dc), wxRect * WXUNUSED(rect))
242 { /* no extra borders for us */ }
243
244 // all our XPMs are of this size
245 static wxSize GetStdBmpSize() { return wxSize(8, 8); }
246
247 wxBitmap GetIndicator(IndicatorType indType, int flags);
248 virtual wxBitmap GetCheckBitmap(int flags)
249 { return GetIndicator(IndicatorType_Check, flags); }
250 virtual wxBitmap GetRadioBitmap(int flags)
251 { return GetIndicator(IndicatorType_Radio, flags); }
252
253 virtual wxBitmap GetFrameButtonBitmap(FrameButtonType type);
254 virtual int GetFrameBorderWidth(int flags) const;
255
256private:
257 // the bitmaps returned by GetIndicator()
258 wxBitmap m_bmpIndicators[IndicatorType_MaxCtrl]
259 [IndicatorState_MaxCtrl]
260 [IndicatorStatus_Max];
261
262 static const char **ms_xpmIndicators[IndicatorType_MaxCtrl]
263 [IndicatorState_MaxCtrl]
264 [IndicatorStatus_Max];
265
266 // the arrow bitmaps used by DrawArrow()
267 wxBitmap m_bmpArrows[Arrow_Max];
268
269 static const char **ms_xpmArrows[Arrow_Max];
270
271 // the close bitmap for the frame for GetFrameButtonBitmap()
272 wxBitmap m_bmpFrameClose;
273
274 // pen used for foreground drawing
275 wxPen m_penFg;
276};
277
278// ----------------------------------------------------------------------------
279// standard bitmaps
280// ----------------------------------------------------------------------------
281
282static const char *xpmUnchecked[] = {
283/* columns rows colors chars-per-pixel */
284"8 8 2 1",
285" c white",
286"X c black",
287/* pixels */
288"XXXXXXXX",
289"X X",
290"X X",
291"X X",
292"X X",
293"X X",
294"X X",
295"XXXXXXXX",
296};
297
298static const char *xpmChecked[] = {
299/* columns rows colors chars-per-pixel */
300"8 8 2 1",
301" c white",
302"X c black",
303/* pixels */
304"XXXXXXXX",
305"X X",
306"X X X X",
307"X XX X",
308"X XX X",
309"X X X X",
310"X X",
311"XXXXXXXX",
312};
313
314static const char *xpmUndeterminate[] = {
315/* columns rows colors chars-per-pixel */
316"8 8 2 1",
317" c white",
318"X c black",
319/* pixels */
320"XXXXXXXX",
321"X X X XX",
322"XX X X X",
323"X X X XX",
324"XX X X X",
325"X X X XX",
326"XX X X X",
327"XXXXXXXX",
328};
329
330static const char *xpmRadioUnchecked[] = {
331/* columns rows colors chars-per-pixel */
332"8 8 2 1",
333" c white",
334"X c black",
335/* pixels */
336"XXXXXXXX",
337"X X",
338"X XX X",
339"X X X X",
340"X X X X",
341"X XX X",
342"X X",
343"XXXXXXXX",
344};
345
346static const char *xpmRadioChecked[] = {
347/* columns rows colors chars-per-pixel */
348"8 8 2 1",
349" c white",
350"X c black",
351/* pixels */
352"XXXXXXXX",
353"X X",
354"X XX X",
355"X XXXX X",
356"X XXXX X",
357"X XX X",
358"X X",
359"XXXXXXXX",
360};
361
362const char **wxMonoRenderer::ms_xpmIndicators[IndicatorType_MaxCtrl]
363 [IndicatorState_MaxCtrl]
364 [IndicatorStatus_Max] =
365{
366 // checkboxes first
367 {
368 // normal state
369 { xpmChecked, xpmUnchecked, xpmUndeterminate },
370
371 // pressed state
372 { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
373
374 // disabled state
375 { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
376 },
377
378 // radio
379 {
380 // normal state
381 { xpmRadioChecked, xpmRadioUnchecked, xpmUndeterminate },
382
383 // pressed state
384 { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
385
386 // disabled state
387 { xpmUndeterminate, xpmUndeterminate, xpmUndeterminate },
388 },
389};
390
391static const char *xpmLeftArrow[] = {
392/* columns rows colors chars-per-pixel */
393"8 8 2 1",
394" c white",
395"X c black",
396/* pixels */
397" X ",
398" XX ",
399" XXX ",
400"XXXX ",
401"XXXX ",
402" XXX ",
403" XX ",
404" X ",
405};
406
407static const char *xpmRightArrow[] = {
408/* columns rows colors chars-per-pixel */
409"8 8 2 1",
410" c white",
411"X c black",
412/* pixels */
413" X ",
414" XX ",
415" XXX ",
416" XXXX",
417" XXXX",
418" XXX ",
419" XX ",
420" X ",
421};
422
423static const char *xpmUpArrow[] = {
424/* columns rows colors chars-per-pixel */
425"8 8 2 1",
426" c white",
427"X c black",
428/* pixels */
429" ",
430" XX ",
431" XXXX ",
432" XXXXXX ",
433"XXXXXXXX",
434" ",
435" ",
436" ",
437};
438
439static const char *xpmDownArrow[] = {
440/* columns rows colors chars-per-pixel */
441"8 8 2 1",
442" c white",
443"X c black",
444/* pixels */
445" ",
446" ",
447" ",
448"XXXXXXXX",
449" XXXXXX ",
450" XXXX ",
451" XX ",
452" ",
453};
454
455const char **wxMonoRenderer::ms_xpmArrows[Arrow_Max] =
456{
457 xpmLeftArrow, xpmRightArrow, xpmUpArrow, xpmDownArrow,
458};
459
460// ----------------------------------------------------------------------------
461// wxMonoColourScheme: uses just white and black
462// ----------------------------------------------------------------------------
463
464class wxMonoColourScheme : public wxColourScheme
465{
466public:
467 // we use only 2 colours, white and black, but we avoid referring to them
468 // like this, instead use the functions below
469 wxColour GetFg() const { return wxMONO_FG_COL; }
470 wxColour GetBg() const { return wxMONO_BG_COL; }
471
472 // implement base class pure virtuals
473 virtual wxColour Get(StdColour col) const;
474 virtual wxColour GetBackground(wxWindow *win) const;
475};
476
477// ----------------------------------------------------------------------------
478// wxMonoArtProvider
479// ----------------------------------------------------------------------------
480
481class wxMonoArtProvider : public wxArtProvider
482{
483protected:
484 virtual wxBitmap CreateBitmap(const wxArtID& id,
485 const wxArtClient& client,
486 const wxSize& size);
487};
488
489// ----------------------------------------------------------------------------
490// wxMonoTheme
491// ----------------------------------------------------------------------------
492
493class wxMonoTheme : public wxTheme
494{
495public:
496 wxMonoTheme();
497 virtual ~wxMonoTheme();
498
499 virtual wxRenderer *GetRenderer();
500 virtual wxArtProvider *GetArtProvider();
501 virtual wxInputHandler *GetInputHandler(const wxString& control,
502 wxInputConsumer *consumer);
503 virtual wxColourScheme *GetColourScheme();
504
505private:
506 wxMonoRenderer *m_renderer;
507 wxMonoArtProvider *m_artProvider;
508 wxMonoColourScheme *m_scheme;
509
510 WX_DECLARE_THEME(mono)
511};
512
513// ============================================================================
514// implementation
515// ============================================================================
516
517WX_IMPLEMENT_THEME(wxMonoTheme, mono, wxTRANSLATE("Simple monochrome theme"));
518
519// ----------------------------------------------------------------------------
520// wxMonoTheme
521// ----------------------------------------------------------------------------
522
523wxMonoTheme::wxMonoTheme()
524{
525 m_scheme = NULL;
526 m_renderer = NULL;
527 m_artProvider = NULL;
528}
529
530wxMonoTheme::~wxMonoTheme()
531{
532 delete m_renderer;
533 delete m_scheme;
534 delete m_artProvider;
535}
536
537wxRenderer *wxMonoTheme::GetRenderer()
538{
539 if ( !m_renderer )
540 {
541 m_renderer = new wxMonoRenderer(GetColourScheme());
542 }
543
544 return m_renderer;
545}
546
547wxArtProvider *wxMonoTheme::GetArtProvider()
548{
549 if ( !m_artProvider )
550 {
551 m_artProvider = new wxMonoArtProvider;
552 }
553
554 return m_artProvider;
555}
556
557wxColourScheme *wxMonoTheme::GetColourScheme()
558{
559 if ( !m_scheme )
560 {
561 m_scheme = new wxMonoColourScheme;
562 }
563
564 return m_scheme;
565}
566
567wxInputHandler *wxMonoTheme::GetInputHandler(const wxString& WXUNUSED(control),
568 wxInputConsumer *consumer)
569{
570 // no special input handlers so far
571 return consumer->DoGetStdInputHandler(NULL);
572}
573
574// ============================================================================
575// wxMonoColourScheme
576// ============================================================================
577
578wxColour wxMonoColourScheme::GetBackground(wxWindow *win) const
579{
580 wxColour col;
581 if ( win->UseBgCol() )
582 {
583 // use the user specified colour
584 col = win->GetBackgroundColour();
585 }
586
587 // doesn't depend on the state
588 if ( !col.Ok() )
589 {
590 col = GetBg();
591 }
592
593 return col;
594}
595
596wxColour wxMonoColourScheme::Get(wxMonoColourScheme::StdColour col) const
597{
598 switch ( col )
599 {
600 case WINDOW:
601 case CONTROL:
602 case CONTROL_PRESSED:
603 case CONTROL_CURRENT:
604 case SCROLLBAR:
605 case SCROLLBAR_PRESSED:
606 case GAUGE:
607 case TITLEBAR:
608 case TITLEBAR_ACTIVE:
609 case HIGHLIGHT_TEXT:
610 case DESKTOP:
611 case FRAME:
612 return GetBg();
613
614 case MAX:
615 default:
616 wxFAIL_MSG(wxT("invalid standard colour"));
617 // fall through
618
619 case SHADOW_DARK:
620 case SHADOW_HIGHLIGHT:
621 case SHADOW_IN:
622 case SHADOW_OUT:
623 case CONTROL_TEXT:
624 case CONTROL_TEXT_DISABLED:
625 case CONTROL_TEXT_DISABLED_SHADOW:
626 case TITLEBAR_TEXT:
627 case TITLEBAR_ACTIVE_TEXT:
628 case HIGHLIGHT:
629 return GetFg();
630
631 }
632}
633
634// ============================================================================
635// wxMonoRenderer
636// ============================================================================
637
638// ----------------------------------------------------------------------------
639// construction
640// ----------------------------------------------------------------------------
641
642wxMonoRenderer::wxMonoRenderer(const wxColourScheme *scheme)
643 : wxStdRenderer(scheme)
644{
645 m_penFg = wxPen(wxMONO_FG_COL);
646}
647
648// ----------------------------------------------------------------------------
649// borders
650// ----------------------------------------------------------------------------
651
652wxRect wxMonoRenderer::GetBorderDimensions(wxBorder border) const
653{
654 wxCoord width;
655 switch ( border )
656 {
657 case wxBORDER_SIMPLE:
658 case wxBORDER_STATIC:
659 case wxBORDER_RAISED:
660 case wxBORDER_SUNKEN:
661 case wxBORDER_THEME:
662 width = 1;
663 break;
664 /*
665 case wxBORDER_DOUBLE:
666 width = 2;
667 break;
668 */
669 default:
670 wxFAIL_MSG(wxT("unknown border type"));
671 // fall through
672
673 case wxBORDER_DEFAULT:
674 case wxBORDER_NONE:
675 width = 0;
676 break;
677 }
678
679 wxRect rect;
680 rect.x =
681 rect.y =
682 rect.width =
683 rect.height = width;
684
685 return rect;
686}
687
688void wxMonoRenderer::DrawButtonBorder(wxDC& dc,
689 const wxRect& rect,
690 int flags,
691 wxRect *rectIn)
692{
693 DrawBorder(dc, wxBORDER_SIMPLE, rect, flags, rectIn);
694}
695
696// ----------------------------------------------------------------------------
697// lines and frames
698// ----------------------------------------------------------------------------
699
700void
701wxMonoRenderer::DrawHorizontalLine(wxDC& dc, wxCoord y, wxCoord x1, wxCoord x2)
702{
703 dc.SetPen(m_penFg);
704 dc.DrawLine(x1, y, x2 + 1, y);
705}
706
707void
708wxMonoRenderer::DrawVerticalLine(wxDC& dc, wxCoord x, wxCoord y1, wxCoord y2)
709{
710 dc.SetPen(m_penFg);
711 dc.DrawLine(x, y1, x, y2 + 1);
712}
713
714void wxMonoRenderer::DrawFocusRect(wxWindow* WXUNUSED(win), wxDC& dc, const wxRect& rect, int flags)
715{
716 // no need to draw the focus rect for selected items, it would be invisible
717 // anyhow
718 if ( !(flags & wxCONTROL_SELECTED) )
719 {
720 dc.SetPen(m_penFg);
721 dc.SetBrush(*wxTRANSPARENT_BRUSH);
722 dc.DrawRectangle(rect);
723 }
724}
725
726// ----------------------------------------------------------------------------
727// label
728// ----------------------------------------------------------------------------
729
730void wxMonoRenderer::DrawLabel(wxDC& dc,
731 const wxString& label,
732 const wxRect& rect,
733 int WXUNUSED(flags),
734 int alignment,
735 int indexAccel,
736 wxRect *rectBounds)
737{
738 dc.DrawLabel(label, wxNullBitmap, rect, alignment, indexAccel, rectBounds);
739}
740
741void wxMonoRenderer::DrawButtonLabel(wxDC& dc,
742 const wxString& label,
743 const wxBitmap& image,
744 const wxRect& rect,
745 int flags,
746 int alignment,
747 int indexAccel,
748 wxRect *rectBounds)
749{
750 dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
751
752 if ( flags & wxCONTROL_DISABLED )
753 {
754 // this is ugly but I don't know how to show disabled button visually
755 // in monochrome theme otherwise, so cross it out
756 dc.SetPen(m_penFg);
757 dc.DrawLine(rect.GetTopLeft(), rect.GetBottomRight());
758 dc.DrawLine(rect.GetTopRight(), rect.GetBottomLeft());
759 }
760}
761
762// ----------------------------------------------------------------------------
763// bitmaps
764// ----------------------------------------------------------------------------
765
766wxBitmap wxMonoRenderer::GetIndicator(IndicatorType indType, int flags)
767{
768 IndicatorState indState;
769 IndicatorStatus indStatus;
770 GetIndicatorsFromFlags(flags, indState, indStatus);
771
772 wxBitmap& bmp = m_bmpIndicators[indType][indState][indStatus];
773 if ( !bmp.Ok() )
774 {
775 const char **xpm = ms_xpmIndicators[indType][indState][indStatus];
776 if ( xpm )
777 {
778 // create and cache it
779 bmp = wxBitmap(xpm);
780 }
781 }
782
783 return bmp;
784}
785
786wxBitmap wxMonoRenderer::GetFrameButtonBitmap(FrameButtonType type)
787{
788 if ( type == FrameButton_Close )
789 {
790 if ( !m_bmpFrameClose.Ok() )
791 {
792 static const char *xpmFrameClose[] = {
793 /* columns rows colors chars-per-pixel */
794 "8 8 2 1",
795 " c white",
796 "X c black",
797 /* pixels */
798 " ",
799 " XX XX ",
800 " X X ",
801 " XX ",
802 " XX ",
803 " X X ",
804 " XX XX ",
805 " ",
806 };
807
808 m_bmpFrameClose = wxBitmap(xpmFrameClose);
809 }
810
811 return m_bmpFrameClose;
812 }
813
814 // we don't show any other buttons than close
815 return wxNullBitmap;
816}
817
818// ----------------------------------------------------------------------------
819// toolbar
820// ----------------------------------------------------------------------------
821
822#if wxUSE_TOOLBAR
823
824void wxMonoRenderer::DrawToolBarButton(wxDC& WXUNUSED(dc),
825 const wxString& WXUNUSED(label),
826 const wxBitmap& WXUNUSED(bitmap),
827 const wxRect& WXUNUSED(rect),
828 int WXUNUSED(flags),
829 long WXUNUSED(style),
830 int WXUNUSED(tbarStyle))
831{
832 wxFAIL_MSG(wxT("TODO"));
833}
834
835wxSize wxMonoRenderer::GetToolBarButtonSize(wxCoord *WXUNUSED(separator)) const
836{
837 wxFAIL_MSG(wxT("TODO"));
838
839 return wxSize();
840}
841
842wxSize wxMonoRenderer::GetToolBarMargin() const
843{
844 wxFAIL_MSG(wxT("TODO"));
845
846 return wxSize();
847}
848
849#endif // wxUSE_TOOLBAR
850
851// ----------------------------------------------------------------------------
852// notebook
853// ----------------------------------------------------------------------------
854
855#if wxUSE_NOTEBOOK
856
857void wxMonoRenderer::DrawTab(wxDC& WXUNUSED(dc),
858 const wxRect& WXUNUSED(rect),
859 wxDirection WXUNUSED(dir),
860 const wxString& WXUNUSED(label),
861 const wxBitmap& WXUNUSED(bitmap),
862 int WXUNUSED(flags),
863 int WXUNUSED(indexAccel))
864{
865 wxFAIL_MSG(wxT("TODO"));
866}
867
868wxSize wxMonoRenderer::GetTabIndent() const
869{
870 wxFAIL_MSG(wxT("TODO"));
871
872 return wxSize();
873}
874
875wxSize wxMonoRenderer::GetTabPadding() const
876{
877 wxFAIL_MSG(wxT("TODO"));
878
879 return wxSize();
880}
881
882#endif // wxUSE_NOTEBOOK
883
884// ----------------------------------------------------------------------------
885// combobox
886// ----------------------------------------------------------------------------
887
888#if wxUSE_COMBOBOX
889
890void wxMonoRenderer::GetComboBitmaps(wxBitmap *WXUNUSED(bmpNormal),
891 wxBitmap *WXUNUSED(bmpFocus),
892 wxBitmap *WXUNUSED(bmpPressed),
893 wxBitmap *WXUNUSED(bmpDisabled))
894{
895 wxFAIL_MSG(wxT("TODO"));
896}
897
898#endif // wxUSE_COMBOBOX
899
900// ----------------------------------------------------------------------------
901// menus
902// ----------------------------------------------------------------------------
903
904#if wxUSE_MENUS
905
906void wxMonoRenderer::DrawMenuBarItem(wxDC& WXUNUSED(dc),
907 const wxRect& WXUNUSED(rect),
908 const wxString& WXUNUSED(label),
909 int WXUNUSED(flags),
910 int WXUNUSED(indexAccel))
911{
912 wxFAIL_MSG(wxT("TODO"));
913}
914
915void wxMonoRenderer::DrawMenuItem(wxDC& WXUNUSED(dc),
916 wxCoord WXUNUSED(y),
917 const wxMenuGeometryInfo& WXUNUSED(geometryInfo),
918 const wxString& WXUNUSED(label),
919 const wxString& WXUNUSED(accel),
920 const wxBitmap& WXUNUSED(bitmap),
921 int WXUNUSED(flags),
922 int WXUNUSED(indexAccel))
923{
924 wxFAIL_MSG(wxT("TODO"));
925}
926
927void wxMonoRenderer::DrawMenuSeparator(wxDC& WXUNUSED(dc),
928 wxCoord WXUNUSED(y),
929 const wxMenuGeometryInfo& WXUNUSED(geomInfo))
930{
931 wxFAIL_MSG(wxT("TODO"));
932}
933
934wxSize wxMonoRenderer::GetMenuBarItemSize(const wxSize& WXUNUSED(sizeText)) const
935{
936 wxFAIL_MSG(wxT("TODO"));
937
938 return wxSize();
939}
940
941wxMenuGeometryInfo *wxMonoRenderer::GetMenuGeometry(wxWindow *WXUNUSED(win),
942 const wxMenu& WXUNUSED(menu)) const
943{
944 wxFAIL_MSG(wxT("TODO"));
945
946 return NULL;
947}
948
949#endif // wxUSE_MENUS
950
951// ----------------------------------------------------------------------------
952// slider
953// ----------------------------------------------------------------------------
954
955#if wxUSE_SLIDER
956
957void wxMonoRenderer::DrawSliderShaft(wxDC& WXUNUSED(dc),
958 const wxRect& WXUNUSED(rect),
959 int WXUNUSED(lenThumb),
960 wxOrientation WXUNUSED(orient),
961 int WXUNUSED(flags),
962 long WXUNUSED(style),
963 wxRect *WXUNUSED(rectShaft))
964{
965 wxFAIL_MSG(wxT("TODO"));
966}
967
968
969void wxMonoRenderer::DrawSliderThumb(wxDC& WXUNUSED(dc),
970 const wxRect& WXUNUSED(rect),
971 wxOrientation WXUNUSED(orient),
972 int WXUNUSED(flags),
973 long WXUNUSED(style))
974{
975 wxFAIL_MSG(wxT("TODO"));
976}
977
978void wxMonoRenderer::DrawSliderTicks(wxDC& WXUNUSED(dc),
979 const wxRect& WXUNUSED(rect),
980 int WXUNUSED(lenThumb),
981 wxOrientation WXUNUSED(orient),
982 int WXUNUSED(start),
983 int WXUNUSED(end),
984 int WXUNUSED(step),
985 int WXUNUSED(flags),
986 long WXUNUSED(style))
987{
988 wxFAIL_MSG(wxT("TODO"));
989}
990
991wxCoord wxMonoRenderer::GetSliderDim() const
992{
993 wxFAIL_MSG(wxT("TODO"));
994
995 return 0;
996}
997
998wxCoord wxMonoRenderer::GetSliderTickLen() const
999{
1000 wxFAIL_MSG(wxT("TODO"));
1001
1002 return 0;
1003}
1004
1005
1006wxRect wxMonoRenderer::GetSliderShaftRect(const wxRect& WXUNUSED(rect),
1007 int WXUNUSED(lenThumb),
1008 wxOrientation WXUNUSED(orient),
1009 long WXUNUSED(style)) const
1010{
1011 wxFAIL_MSG(wxT("TODO"));
1012
1013 return wxRect();
1014}
1015
1016wxSize wxMonoRenderer::GetSliderThumbSize(const wxRect& WXUNUSED(rect),
1017 int WXUNUSED(lenThumb),
1018 wxOrientation WXUNUSED(orient)) const
1019{
1020 wxFAIL_MSG(wxT("TODO"));
1021
1022 return wxSize();
1023}
1024
1025#endif // wxUSE_SLIDER
1026
1027wxSize wxMonoRenderer::GetProgressBarStep() const
1028{
1029 wxFAIL_MSG(wxT("TODO"));
1030
1031 return wxSize();
1032}
1033
1034
1035// ----------------------------------------------------------------------------
1036// scrollbar
1037// ----------------------------------------------------------------------------
1038
1039void wxMonoRenderer::DrawArrow(wxDC& dc,
1040 wxDirection dir,
1041 const wxRect& rect,
1042 int WXUNUSED(flags))
1043{
1044 ArrowDirection arrowDir = GetArrowDirection(dir);
1045 wxCHECK_RET( arrowDir != Arrow_Max, wxT("invalid arrow direction") );
1046
1047 wxBitmap& bmp = m_bmpArrows[arrowDir];
1048 if ( !bmp.Ok() )
1049 {
1050 bmp = wxBitmap(ms_xpmArrows[arrowDir]);
1051 }
1052
1053 wxRect rectArrow(0, 0, bmp.GetWidth(), bmp.GetHeight());
1054 dc.DrawBitmap(bmp, rectArrow.CentreIn(rect).GetPosition(), true /* use mask */);
1055}
1056
1057void wxMonoRenderer::DrawScrollbarThumb(wxDC& dc,
1058 wxOrientation WXUNUSED(orient),
1059 const wxRect& rect,
1060 int WXUNUSED(flags))
1061{
1062 DrawSolidRect(dc, wxMONO_BG_COL, rect);
1063
1064 // manually draw stipple pattern (wxDFB doesn't implement the wxSTIPPLE
1065 // brush style):
1066 dc.SetPen(m_penFg);
1067 for ( wxCoord y = rect.GetTop(); y <= rect.GetBottom(); y++ )
1068 {
1069 for ( wxCoord x = rect.GetLeft() + (y % 2); x <= rect.GetRight(); x+=2 )
1070 {
1071 dc.DrawPoint(x, y);
1072 }
1073 }
1074}
1075
1076void wxMonoRenderer::DrawScrollbarShaft(wxDC& dc,
1077 wxOrientation WXUNUSED(orient),
1078 const wxRect& rect,
1079 int WXUNUSED(flags))
1080{
1081 DrawSolidRect(dc, wxMONO_BG_COL, rect);
1082}
1083
1084// ----------------------------------------------------------------------------
1085// status bar
1086// ----------------------------------------------------------------------------
1087
1088#if wxUSE_STATUSBAR
1089
1090wxCoord wxMonoRenderer::GetStatusBarBorderBetweenFields() const
1091{
1092 return 1;
1093}
1094
1095wxSize wxMonoRenderer::GetStatusBarFieldMargins() const
1096{
1097 return wxSize(1, 1);
1098}
1099
1100#endif // wxUSE_STATUSBAR
1101
1102// ----------------------------------------------------------------------------
1103// top level windows
1104// ----------------------------------------------------------------------------
1105
1106int wxMonoRenderer::GetFrameBorderWidth(int WXUNUSED(flags)) const
1107{
1108 // all our borders are simple
1109 return 1;
1110}
1111
1112// ----------------------------------------------------------------------------
1113// wxMonoArtProvider
1114// ----------------------------------------------------------------------------
1115
1116wxBitmap wxMonoArtProvider::CreateBitmap(const wxArtID& WXUNUSED(id),
1117 const wxArtClient& WXUNUSED(client),
1118 const wxSize& WXUNUSED(size))
1119{
1120 return wxNullBitmap;
1121}
1122
1123#endif // wxUSE_THEME_MONO
wxWidgets (Impactor)