]> git.saurik.com Git - wxWidgets.git/blame - src/univ/themes/mono.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
preliminary editing support
[wxWidgets.git] / src / univ / themes / mono.cpp
CommitLineData
147b8a4a
VZ		 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#ifndef WX_PRECOMP
28#endif // WX_PRECOMP
29
30#include "wx/univ/renderer.h"
31#include "wx/univ/inphand.h"
32#include "wx/univ/colschem.h"
33#include "wx/univ/theme.h"
34
35class wxMonoColourScheme;
36
37#define wxMONO_BG_COL (*wxWHITE)
38#define wxMONO_FG_COL (*wxBLACK)
39
40// ----------------------------------------------------------------------------
41// wxMonoRenderer: draw the GUI elements in simplest possible way
42// ----------------------------------------------------------------------------
43
44// Warning: many of the methods here are not implemented, the code won't work
45// if any but a few wxUSE_XXXs are on
46class wxMonoRenderer : public wxStdRenderer
47{
48public:
49 wxMonoRenderer(const wxColourScheme *scheme);
50
51 virtual void DrawBackground(wxDC& dc,
52 const wxColour& col,
53 const wxRect& rect,
54 int flags,
55 wxWindow *window = NULL);
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
65 virtual void DrawButtonLabel(wxDC& dc,
66 const wxString& label,
67 const wxBitmap& image,
68 const wxRect& rect,
69 int flags = 0,
70 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
71 int indexAccel = -1,
72 wxRect *rectBounds = NULL);
73
74 virtual void DrawBorder(wxDC& dc,
75 wxBorder border,
76 const wxRect& rect,
77 int flags = 0,
78 wxRect *rectIn = NULL);
79
80 virtual void DrawTextBorder(wxDC& dc,
81 wxBorder border,
82 const wxRect& rect,
83 int flags = 0,
84 wxRect *rectIn = NULL);
85
86 virtual void DrawButtonBorder(wxDC& dc,
87 const wxRect& rect,
88 int flags = 0,
89 wxRect *rectIn = NULL);
90
91 virtual void DrawHorizontalLine(wxDC& dc,
92 wxCoord y, wxCoord x1, wxCoord x2);
93
94 virtual void DrawVerticalLine(wxDC& dc,
95 wxCoord x, wxCoord y1, wxCoord y2);
96
97 virtual void DrawFrame(wxDC& dc,
98 const wxString& label,
99 const wxRect& rect,
100 int flags = 0,
101 int alignment = wxALIGN_LEFT,
102 int indexAccel = -1);
103
104 virtual void DrawArrow(wxDC& dc,
105 wxDirection dir,
106 const wxRect& rect,
107 int flags = 0);
108
109 virtual void DrawScrollbarArrow(wxDC& dc,
110 wxDirection dir,
111 const wxRect& rect,
112 int flags = 0);
113
114 virtual void DrawScrollbarThumb(wxDC& dc,
115 wxOrientation orient,
116 const wxRect& rect,
117 int flags = 0);
118
119 virtual void DrawScrollbarShaft(wxDC& dc,
120 wxOrientation orient,
121 const wxRect& rect,
122 int flags = 0);
123
124 virtual void DrawScrollCorner(wxDC& dc,
125 const wxRect& rect);
126
127 virtual void DrawItem(wxDC& dc,
128 const wxString& label,
129 const wxRect& rect,
130 int flags = 0);
131
132 virtual void DrawCheckItem(wxDC& dc,
133 const wxString& label,
134 const wxBitmap& bitmap,
135 const wxRect& rect,
136 int flags = 0);
137
138 virtual void DrawCheckButton(wxDC& dc,
139 const wxString& label,
140 const wxBitmap& bitmap,
141 const wxRect& rect,
142 int flags = 0,
143 wxAlignment align = wxALIGN_LEFT,
144 int indexAccel = -1);
145
146 virtual void DrawRadioButton(wxDC& dc,
147 const wxString& label,
148 const wxBitmap& bitmap,
149 const wxRect& rect,
150 int flags = 0,
151 wxAlignment align = wxALIGN_LEFT,
152 int indexAccel = -1);
153
154#if wxUSE_TOOLBAR
155 virtual void DrawToolBarButton(wxDC& dc,
156 const wxString& label,
157 const wxBitmap& bitmap,
158 const wxRect& rect,
159 int flags = 0,
160 long style = 0,
161 int tbarStyle = 0);
162#endif // wxUSE_TOOLBAR
163
164#if wxUSE_TEXTCTRL
165 virtual void DrawTextLine(wxDC& dc,
166 const wxString& text,
167 const wxRect& rect,
168 int selStart = -1,
169 int selEnd = -1,
170 int flags = 0);
171
172 virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
173#endif // wxUSE_TEXTCTRL
174
175#if wxUSE_NOTEBOOK
176 virtual void DrawTab(wxDC& dc,
177 const wxRect& rect,
178 wxDirection dir,
179 const wxString& label,
180 const wxBitmap& bitmap = wxNullBitmap,
181 int flags = 0,
182 int indexAccel = -1);
183#endif // wxUSE_NOTEBOOK
184
185#if wxUSE_SLIDER
186
187 virtual void DrawSliderShaft(wxDC& dc,
188 const wxRect& rect,
189 int lenThumb,
190 wxOrientation orient,
191 int flags = 0,
192 long style = 0,
193 wxRect *rectShaft = NULL);
194
195 virtual void DrawSliderThumb(wxDC& dc,
196 const wxRect& rect,
197 wxOrientation orient,
198 int flags = 0,
199 long style = 0);
200
201 virtual void DrawSliderTicks(wxDC& dc,
202 const wxRect& rect,
203 int lenThumb,
204 wxOrientation orient,
205 int start,
206 int end,
207 int step = 1,
208 int flags = 0,
209 long style = 0);
210#endif // wxUSE_SLIDER
211
212#if wxUSE_MENUS
213 virtual void DrawMenuBarItem(wxDC& dc,
214 const wxRect& rect,
215 const wxString& label,
216 int flags = 0,
217 int indexAccel = -1);
218
219 virtual void DrawMenuItem(wxDC& dc,
220 wxCoord y,
221 const wxMenuGeometryInfo& geometryInfo,
222 const wxString& label,
223 const wxString& accel,
224 const wxBitmap& bitmap = wxNullBitmap,
225 int flags = 0,
226 int indexAccel = -1);
227
228 virtual void DrawMenuSeparator(wxDC& dc,
229 wxCoord y,
230 const wxMenuGeometryInfo& geomInfo);
231#endif // wxUSE_MENUS
232
233#if wxUSE_STATUSBAR
234 virtual void DrawStatusField(wxDC& dc,
235 const wxRect& rect,
236 const wxString& label,
237 int flags = 0, int style = 0);
238#endif // wxUSE_STATUSBAR
239
240 virtual void DrawFrameTitleBar(wxDC& dc,
241 const wxRect& rect,
242 const wxString& title,
243 const wxIcon& icon,
244 int flags,
245 int specialButton = 0,
246 int specialButtonFlags = 0);
247
248 virtual void DrawFrameBorder(wxDC& dc,
249 const wxRect& rect,
250 int flags);
251
252 virtual void DrawFrameBackground(wxDC& dc,
253 const wxRect& rect,
254 int flags);
255
256 virtual void DrawFrameTitle(wxDC& dc,
257 const wxRect& rect,
258 const wxString& title,
259 int flags);
260
261 virtual void DrawFrameIcon(wxDC& dc,
262 const wxRect& rect,
263 const wxIcon& icon,
264 int flags);
265
266 virtual void DrawFrameButton(wxDC& dc,
267 wxCoord x, wxCoord y,
268 int button,
269 int flags = 0);
270
271
272 virtual void GetComboBitmaps(wxBitmap *bmpNormal,
273 wxBitmap *bmpFocus,
274 wxBitmap *bmpPressed,
275 wxBitmap *bmpDisabled);
276
277
278 virtual wxRect GetBorderDimensions(wxBorder border) const;
279
280 virtual bool AreScrollbarsInsideBorder() const;
281
282 virtual void AdjustSize(wxSize *size, const wxWindow *window);
283
284#if wxUSE_SCROLLBAR
285
286 virtual wxSize GetScrollbarArrowSize() const;
287
288 virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
289 wxScrollBar::Element elem,
290 int thumbPos = -1) const;
291
292 virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
293
294 virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
295 const wxPoint& pt) const;
296
297 virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
298 int thumbPos = -1);
299 virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
300 wxCoord coord);
301
302#endif // wxUSE_SCROLLBAR
303
304 virtual wxCoord GetListboxItemHeight(wxCoord fontHeight);
305
306 virtual wxSize GetCheckBitmapSize() const;
307 virtual wxSize GetRadioBitmapSize() const;
308 virtual wxCoord GetCheckItemMargin() const;
309
310 virtual wxSize GetToolBarButtonSize(wxCoord *separator) const;
311
312 virtual wxSize GetToolBarMargin() const;
313
314#if wxUSE_TEXTCTRL
315 virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
316 const wxRect& rectText) const;
317
318 virtual wxRect GetTextClientArea(const wxTextCtrl *text,
319 const wxRect& rectTotal,
320 wxCoord *extraSpaceBeyond) const;
321#endif // wxUSE_TEXTCTRL
322
323#if wxUSE_NOTEBOOK
324 virtual wxSize GetTabIndent() const;
325
326 virtual wxSize GetTabPadding() const;
327#endif // wxUSE_NOTEBOOK
328
329#if wxUSE_SLIDER
330 virtual wxCoord GetSliderDim() const;
331
332 virtual wxCoord GetSliderTickLen() const;
333
334 virtual wxRect GetSliderShaftRect(const wxRect& rect,
335 int lenThumb,
336 wxOrientation orient,
337 long style = 0) const;
338
339 virtual wxSize GetSliderThumbSize(const wxRect& rect,
340 int lenThumb,
341 wxOrientation orient) const;
342#endif // wxUSE_SLIDER
343
344 virtual wxSize GetProgressBarStep() const;
345
346#if wxUSE_MENUS
347 virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
348
349 virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
350 const wxMenu& menu) const;
351#endif // wxUSE_MENUS
352
353#if wxUSE_STATUSBAR
354 virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
355#endif // wxUSE_STATUSBAR
356
357 virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
358
359 virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
360
361 virtual wxSize GetFrameMinSize(int flags) const;
362
363 virtual wxSize GetFrameIconSize() const;
364
365 virtual int HitTestFrame(const wxRect& rect,
366 const wxPoint& pt,
367 int flags = 0) const;
368
369protected:
370 // draw the background with any colour, not only the default one(s)
371 void DoDrawBackground(wxDC& dc,
372 const wxColour& col,
373 const wxRect& rect,
374 wxWindow *window = NULL);
375
376 // DrawBorder() helpers: all of them shift and clip the DC after drawing
377 // the border
378
379 // just draw a rectangle with the given pen
380 void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
381
382 // draw an opened rect for the arrow in given direction
383 void DrawArrowBorder(wxDC& dc,
384 wxRect *rect,
385 wxDirection dir);
386
387 // draw two sides of the rectangle
388 void DrawThumbBorder(wxDC& dc,
389 wxRect *rect,
390 wxOrientation orient);
391
392#if wxUSE_SCROLLBAR
393 // returns the size of the arrow for the scrollbar (depends on
394 // orientation)
395 wxSize GetScrollbarArrowSize(const wxScrollBar *scrollbar) const
396 {
397 wxSize size;
398 if ( scrollbar->IsVertical() )
399 {
400 size = m_sizeScrollbarArrow;
401 }
402 else
403 {
404 size.x = m_sizeScrollbarArrow.y;
405 size.y = m_sizeScrollbarArrow.x;
406 }
407
408 return size;
409 }
410#endif // wxUSE_SCROLLBAR
411
412 // DrawCheckBitmap and DrawRadioBitmap helpers
413
414 // draw the check bitmaps once and cache them for later use
415 wxBitmap GetCheckBitmap(int flags);
416
417 // draw a /\ or \/ line from (x1, y1) to (x2, y1) passing by the point
418 // ((x1 + x2)/2, y2)
419 void DrawUpZag(wxDC& dc,
420 wxCoord x1, wxCoord x2,
421 wxCoord y1, wxCoord y2);
422 void DrawDownZag(wxDC& dc,
423 wxCoord x1, wxCoord x2,
424 wxCoord y1, wxCoord y2);
425
426 // draw the radio button bitmap for the given state
427 void DrawRadioBitmap(wxDC& dc, const wxRect& rect, int flags);
428
429 // draw check/radio - the bitmap must be a valid one by now
430 void DoDrawCheckOrRadioBitmap(wxDC& dc,
431 const wxString& label,
432 const wxBitmap& bitmap,
433 const wxRect& rectTotal,
434 int flags,
435 wxAlignment align,
436 int indexAccel);
437
438 // common part of DrawMenuItem() and DrawMenuBarItem()
439 void DoDrawMenuItem(wxDC& dc,
440 const wxRect& rect,
441 const wxString& label,
442 int flags,
443 int indexAccel,
444 const wxString& accel = wxEmptyString,
445 const wxBitmap& bitmap = wxNullBitmap,
446 const wxMonoMenuGeometryInfo *geometryInfo = NULL);
447
448#if wxUSE_COMBOBOX
449 // initialize the combo bitmaps
450 void InitComboBitmaps();
451#endif // wxUSE_COMBOBOX
452
453private:
454 // data
455 wxSize m_sizeScrollbarArrow;
456
457 // the checkbox bitmaps: first row is for the normal, second for the
458 // pressed state and the columns are for checked, unchecked and
459 // undeterminated respectively
460 wxBitmap m_bitmapsCheckbox[2][3];
461
462 // the combobox bitmaps
463 enum
464 {
465 ComboState_Normal,
466 ComboState_Focus,
467 ComboState_Pressed,
468 ComboState_Disabled,
469 ComboState_Max
470 };
471
472 wxBitmap m_bitmapsCombo[ComboState_Max];
473};
474
475// ----------------------------------------------------------------------------
476// wxMonoInputHandler
477// ----------------------------------------------------------------------------
478
479class wxMonoInputHandler : public wxInputHandler
480{
481public:
482 wxMonoInputHandler(wxMonoRenderer *renderer);
483
484 virtual bool HandleKey(wxInputConsumer *control,
485 const wxKeyEvent& event,
486 bool pressed);
487 virtual bool HandleMouse(wxInputConsumer *control,
488 const wxMouseEvent& event);
489 virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
490
491protected:
492 wxMonoRenderer *m_renderer;
493};
494
495// ----------------------------------------------------------------------------
496// wxMonoColourScheme: uses just white and black
497// ----------------------------------------------------------------------------
498
499class wxMonoColourScheme : public wxColourScheme
500{
501public:
502 // we use only 2 colours, white and black, but we avoid referring to them
503 // like this, instead use the functions below
504 wxColour GetFg() const { return wxMONO_FG_COL; }
505 wxColour GetBg() const { return wxMONO_BG_COL; }
506
507 // implement base class pure virtuals
508 virtual wxColour Get(StdColour col) const;
509 virtual wxColour GetBackground(wxWindow *win) const;
510};
511
512// ----------------------------------------------------------------------------
513// wxMonoArtProvider
514// ----------------------------------------------------------------------------
515
516class wxMonoArtProvider : public wxArtProvider
517{
518protected:
519 virtual wxBitmap CreateBitmap(const wxArtID& id,
520 const wxArtClient& client,
521 const wxSize& size);
522};
523
524// ----------------------------------------------------------------------------
525// wxMonoTheme
526// ----------------------------------------------------------------------------
527
528WX_DEFINE_ARRAY_PTR(wxInputHandler *, wxArrayHandlers);
529
530class wxMonoTheme : public wxTheme
531{
532public:
533 wxMonoTheme();
534 virtual ~wxMonoTheme();
535
536 virtual wxRenderer *GetRenderer();
537 virtual wxArtProvider *GetArtProvider();
538 virtual wxInputHandler *GetInputHandler(const wxString& control);
539 virtual wxColourScheme *GetColourScheme();
540
541private:
542 wxMonoRenderer *m_renderer;
543 wxMonoArtProvider *m_artProvider;
544 wxMonoColourScheme *m_scheme;
545
546 WX_DECLARE_THEME(gtk)
547};
548
549// ============================================================================
550// implementation
551// ============================================================================
552
553WX_IMPLEMENT_THEME(wxMonoTheme, mono, wxTRANSLATE("Simple monochrome theme"));
554
555// ----------------------------------------------------------------------------
556// wxMonoTheme
557// ----------------------------------------------------------------------------
558
559wxMonoTheme::wxMonoTheme()
560{
561 m_scheme = NULL;
562 m_renderer = NULL;
563 m_artProvider = NULL;
564}
565
566wxMonoTheme::~wxMonoTheme()
567{
568 delete m_renderer;
569 delete m_scheme;
570 wxArtProvider::RemoveProvider(m_artProvider);
571}
572
573wxRenderer *wxMonoTheme::GetRenderer()
574{
575 if ( !m_renderer )
576 {
577 m_renderer = new wxMonoRenderer(GetColourScheme());
578 }
579
580 return m_renderer;
581}
582
583wxArtProvider *wxMonoTheme::GetArtProvider()
584{
585 if ( !m_artProvider )
586 {
587 m_artProvider = new wxMonoArtProvider;
588 }
589
590 return m_artProvider;
591}
592
593wxColourScheme *wxMonoTheme::GetColourScheme()
594{
595 if ( !m_scheme )
596 {
597 m_scheme = new wxMonoColourScheme;
598 }
599
600 return m_scheme;
601}
602
603wxInputHandler *wxMonoTheme::GetInputHandler(const wxString& WXUNUSED(control),
604 wxInputConsumer *consumer)
605{
606 // no special input handlers so far
607 return consumer->DoGetStdInputHandler(NULL);
608}
609
610// ============================================================================
611// wxMonoColourScheme
612// ============================================================================
613
614wxColour wxMonoColourScheme::GetBackground(wxWindow *win) const
615{
616 wxColour col;
617 if ( win->UseBgCol() )
618 {
619 // use the user specified colour
620 col = win->GetBackgroundColour();
621 }
622
623 // doesn't depend on the state
624 if ( !col.Ok() )
625 {
626 col = GetBg();
627 }
628}
629
630wxColour wxMonoColourScheme::Get(wxMonoColourScheme::StdColour col) const
631{
632 switch ( col )
633 {
634 case WINDOW:
635 case CONTROL:
636 case CONTROL_PRESSED:
637 case CONTROL_CURRENT:
638 case SCROLLBAR:
639 case SCROLLBAR_PRESSED:
640 case GAUGE:
641 case HIGHLIGHT:
642 case TITLEBAR:
643 case TITLEBAR_ACTIVE:
644 case DESKTOP:
645 return GetBg();
646
647 case MAX:
648 default:
649 wxFAIL_MSG(_T("invalid standard colour"));
650 // fall through
651
652 case SHADOW_DARK:
653 case SHADOW_HIGHLIGHT:
654 case SHADOW_IN:
655 case SHADOW_OUT:
656 case CONTROL_TEXT:
657 case CONTROL_TEXT_DISABLED:
658 case CONTROL_TEXT_DISABLED_SHADOW:
659 case HIGHLIGHT_TEXT:
660 case TITLEBAR_TEXT:
661 case TITLEBAR_ACTIVE_TEXT:
662 return GetFg();
663
664 }
665}
666
667// ============================================================================
668// wxMonoRenderer
669// ============================================================================
670
671// ----------------------------------------------------------------------------
672// construction
673// ----------------------------------------------------------------------------
674
675wxMonoRenderer::wxMonoRenderer(const wxColourScheme *scheme)
676 : wxStdRenderer(scheme)
677{
678 m_penFg = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT));
679}
680
681// ----------------------------------------------------------------------------
682// border stuff
683// ----------------------------------------------------------------------------
684
685// ----------------------------------------------------------------------------
686// special borders
687// ----------------------------------------------------------------------------
688
689void wxMonoRenderer::DrawTextBorder(wxDC& dc,
690 wxBorder border,
691 const wxRect& rectOrig,
692 int flags,
693 wxRect *rectIn)
694{
695 DrawBorder(dc, border, rectOrig, flags, rectIn);
696}
697
698void wxMonoRenderer::DrawButtonBorder(wxDC& dc,
699 const wxRect& rectTotal,
700 int flags,
701 wxRect *rectIn)
702{
703 DrawBorder(dc, wxBORDER_SIMPLE, rectOrig, flags, rectIn);
704}
705
706// ----------------------------------------------------------------------------
707// lines and frames
708// ----------------------------------------------------------------------------
709
710void
711wxMonoRenderer::DrawHorizontalLine(wxDC& dc, wxCoord y, wxCoord x1, wxCoord x2)
712{
713 dc.SetPen(m_penFg);
714 dc.DrawLine(x1, y, x2 + 1, y);
715}
716
717void
718wxMonoRenderer::DrawVerticalLine(wxDC& dc, wxCoord x, wxCoord y1, wxCoord y2)
719{
720 dc.SetPen(m_penFg);
721 dc.DrawLine(x, y1, x, y2 + 1);
722}
723
724void wxMonoRenderer::DrawFrame(wxDC& dc,
725 const wxString& label,
726 const wxRect& rect,
727 int flags,
728 int alignment,
729 int indexAccel)
730{
731 wxCoord height = 0; // of the label
732 wxRect rectFrame = rect;
733 if ( !label.empty() )
734 {
735 // the text should touch the top border of the rect, so the frame
736 // itself should be lower
737 dc.GetTextExtent(label, NULL, &height);
738 rectFrame.y += height / 2;
739 rectFrame.height -= height / 2;
740
741 // TODO: the +4 should be customizable
742
743 wxRect rectText;
744 rectText.x = rectFrame.x + 4;
745 rectText.y = rect.y;
746 rectText.width = rectFrame.width - 8;
747 rectText.height = height;
748
749 wxRect rectLabel;
750 DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
751 rectLabel.x -= 1;
752 rectLabel.width += 2;
753
754 StandardDrawFrame(dc, rectFrame, rectLabel);
755 }
756 else // no label
757 {
758 // just draw the complete frame
759 DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
760 DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
761 }
762}
763
764// ----------------------------------------------------------------------------
765// label
766// ----------------------------------------------------------------------------
767
768void wxMonoRenderer::DrawLabel(wxDC& dc,
769 const wxString& label,
770 const wxRect& rect,
771 int flags,
772 int alignment,
773 int indexAccel,
774 wxRect *rectBounds)
775{
776 DrawButtonLabel(dc, label, wxNullBitmap, rect, flags,
777 alignment, indexAccel, rectBounds);
778}
779
780void wxMonoRenderer::DrawButtonLabel(wxDC& dc,
781 const wxString& label,
782 const wxBitmap& image,
783 const wxRect& rect,
784 int flags,
785 int alignment,
786 int indexAccel,
787 wxRect *rectBounds)
788{
789 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, CONTROL_TEXT));
790 dc.DrawLabel(label, image, rect, alignment, indexAccel, rectBounds);
791
792 if ( flags & wxCONTROL_DISABLED )
793 {
794 // this is ugly but I don't know how to show disabled button visually
795 // in monochrome theme otherwise
796 dc.SetPen(m_penFg);
797 dc.DrawLine(rect.GetTopLeft(), rect.GetBottomRight());
798 dc.DrawLine(rect.GetTopRight(), rect.GetBottomLeft());
799 }
800}
801
802void wxMonoRenderer::DrawItem(wxDC& dc,
803 const wxString& label,
804 const wxRect& rect,
805 int flags)
806{
807 wxColour colFg;
808 if ( flags & wxCONTROL_SELECTED )
809 {
810 dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT), wxSOLID));
811 dc.SetPen(*wxTRANSPARENT_PEN);
812 dc.DrawRectangle(rect);
813
814 colFg = dc.GetTextForeground();
815 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
816 }
817
818 if ( flags & wxCONTROL_FOCUSED )
819 {
820 dc.SetBrush(*wxTRANSPARENT_BRUSH);
821 wxRect rectFocus = rect;
822 DrawRect(dc, &rectFocus, m_penBlack);
823 }
824
825 wxRect rectText = rect;
826 rectText.x += 2;
827 rectText.y++;
828 dc.DrawLabel(label, wxNullBitmap, rectText);
829
830 if ( flags & wxCONTROL_SELECTED )
831 {
832 dc.SetBackgroundMode(wxTRANSPARENT);
833 }
834
835 // restore the text colour
836 if ( colFg.Ok() )
837 {
838 dc.SetTextForeground(colFg);
839 }
840}
841
842void wxMonoRenderer::DrawCheckItem(wxDC& dc,
843 const wxString& label,
844 const wxBitmap& bitmap,
845 const wxRect& rect,
846 int flags)
847{
848 wxRect rectBitmap = rect;
849 rectBitmap.x -= 1;
850 rectBitmap.width = GetCheckBitmapSize().x;
851
852 // never draw the focus rect around the check indicators here
853 DrawCheckButton(dc, wxEmptyString, bitmap, rectBitmap, flags & ~wxCONTROL_FOCUSED);
854
855 wxRect rectLabel = rect;
856 wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
857 rectLabel.x += shift;
858 rectLabel.width -= shift;
859 DrawItem(dc, label, rectLabel, flags);
860}
861
862// ----------------------------------------------------------------------------
863// check/radion buttons
864// ----------------------------------------------------------------------------
865
866void wxMonoRenderer::DrawUndeterminedBitmap(wxDC& dc,
867 const wxRect& rectTotal,
868 bool isPressed)
869{
870 // FIXME: For sure it is not Mono look but it is better than nothing.
871 // Show me correct look and I will immediatelly make it better (ABX)
872 wxRect rect = rectTotal;
873
874 wxColour col1, col2;
875
876 if ( isPressed )
877 {
878 col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
879 col2 = wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED);
880 }
881 else
882 {
883 col1 = wxSCHEME_COLOUR(m_scheme, SHADOW_DARK);
884 col2 = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
885 }
886
887 dc.SetPen(*wxTRANSPARENT_PEN);
888 dc.SetBrush(wxBrush(col1, wxSOLID));
889 dc.DrawRectangle(rect);
890 rect.Deflate(1);
891 dc.SetBrush(wxBrush(col2, wxSOLID));
892 dc.DrawRectangle(rect);
893}
894
895void wxMonoRenderer::DrawUncheckBitmap(wxDC& dc,
896 const wxRect& rectTotal,
897 bool isPressed)
898{
899 wxRect rect = rectTotal;
900 DrawAntiRaisedBorder(dc, &rect);
901
902 wxColour col = wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
903 dc.SetPen(wxPen(col, 0, wxSOLID));
904 dc.DrawPoint(rect.GetRight() - 1, rect.GetBottom() - 1);
905
906 if ( isPressed )
907 col = wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED);
908 //else: it is SHADOW_IN, leave as is
909
910 dc.SetPen(*wxTRANSPARENT_PEN);
911 dc.SetBrush(wxBrush(col, wxSOLID));
912 dc.DrawRectangle(rect);
913}
914
915void wxMonoRenderer::DrawCheckBitmap(wxDC& dc, const wxRect& rectTotal)
916{
917 wxRect rect = rectTotal;
918 DrawAntiShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
919 DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
920
921 dc.SetPen(*wxTRANSPARENT_PEN);
922 dc.SetBrush(wxBrush(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), wxSOLID));
923 dc.DrawRectangle(rect);
924}
925
926void wxMonoRenderer::DrawRadioBitmap(wxDC& dc,
927 const wxRect& rect,
928 int flags)
929{
930 wxCoord x = rect.x,
931 y = rect.y,
932 xRight = rect.GetRight(),
933 yBottom = rect.GetBottom();
934
935 wxCoord yMid = (y + yBottom) / 2;
936
937 // this looks ugly when the background colour of the control is not the
938 // same ours - radiobox is not transparent as it should be
939#if 0
940 // first fill the middle: as FloodFill() is not implemented on all
941 // platforms, this is the only thing to do
942 wxColour colBg = flags & wxCONTROL_CURRENT
943 ? wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT)
944 : wxSCHEME_COLOUR(m_scheme, SHADOW_IN);
945 dc.SetBrush(wxBrush(colBg, wxSOLID));
946 dc.SetPen(*wxTRANSPARENT_PEN);
947 dc.DrawRectangle(rect);
948#endif // 0
949
950 // then draw the upper half
951 dc.SetPen(flags & wxCONTROL_CHECKED ? m_penDarkGrey : m_penHighlight);
952 DrawUpZag(dc, x, xRight, yMid, y);
953 DrawUpZag(dc, x + 1, xRight - 1, yMid, y + 1);
954
955 bool drawIt = true;
956 if ( flags & wxCONTROL_CHECKED )
957 dc.SetPen(m_penBlack);
958 else if ( flags & wxCONTROL_PRESSED )
959 dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
960 else // unchecked and unpressed
961 drawIt = false;
962
963 if ( drawIt )
964 DrawUpZag(dc, x + 2, xRight - 2, yMid, y + 2);
965
966 // and then the lower one
967 dc.SetPen(flags & wxCONTROL_CHECKED ? m_penHighlight : m_penBlack);
968 DrawDownZag(dc, x, xRight, yMid, yBottom);
969 if ( !(flags & wxCONTROL_CHECKED) )
970 dc.SetPen(m_penDarkGrey);
971 DrawDownZag(dc, x + 1, xRight - 1, yMid, yBottom - 1);
972
973 if ( !(flags & wxCONTROL_CHECKED) )
974 drawIt = true; // with the same pen
975 else if ( flags & wxCONTROL_PRESSED )
976 {
977 dc.SetPen(wxPen(wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), 0, wxSOLID));
978 drawIt = true;
979 }
980 else // checked and unpressed
981 drawIt = false;
982
983 if ( drawIt )
984 DrawDownZag(dc, x + 2, xRight - 2, yMid, yBottom - 2);
985}
986
987void wxMonoRenderer::DrawUpZag(wxDC& dc,
988 wxCoord x1,
989 wxCoord x2,
990 wxCoord y1,
991 wxCoord y2)
992{
993 wxCoord xMid = (x1 + x2) / 2;
994 dc.DrawLine(x1, y1, xMid, y2);
995 dc.DrawLine(xMid, y2, x2 + 1, y1 + 1);
996}
997
998void wxMonoRenderer::DrawDownZag(wxDC& dc,
999 wxCoord x1,
1000 wxCoord x2,
1001 wxCoord y1,
1002 wxCoord y2)
1003{
1004 wxCoord xMid = (x1 + x2) / 2;
1005 dc.DrawLine(x1 + 1, y1 + 1, xMid, y2);
1006 dc.DrawLine(xMid, y2, x2, y1);
1007}
1008
1009wxBitmap wxMonoRenderer::GetCheckBitmap(int flags)
1010{
1011 if ( !m_bitmapsCheckbox[0][0].Ok() )
1012 {
1013 // init the bitmaps once only
1014 wxRect rect;
1015 wxSize size = GetCheckBitmapSize();
1016 rect.width = size.x;
1017 rect.height = size.y;
1018 for ( int i = 0; i < 2; i++ )
1019 {
1020 for ( int j = 0; j < 3; j++ )
1021 m_bitmapsCheckbox[i][j].Create(rect.width, rect.height);
1022 }
1023
1024 wxMemoryDC dc;
1025
1026 // normal checked
1027 dc.SelectObject(m_bitmapsCheckbox[0][0]);
1028 DrawCheckBitmap(dc, rect);
1029
1030 // normal unchecked
1031 dc.SelectObject(m_bitmapsCheckbox[0][1]);
1032 DrawUncheckBitmap(dc, rect, false);
1033
1034 // normal undeterminated
1035 dc.SelectObject(m_bitmapsCheckbox[0][2]);
1036 DrawUndeterminedBitmap(dc, rect, false);
1037
1038 // pressed checked
1039 m_bitmapsCheckbox[1][0] = m_bitmapsCheckbox[0][0];
1040
1041 // pressed unchecked
1042 dc.SelectObject(m_bitmapsCheckbox[1][1]);
1043 DrawUncheckBitmap(dc, rect, true);
1044
1045 // pressed undeterminated
1046 dc.SelectObject(m_bitmapsCheckbox[1][2]);
1047 DrawUndeterminedBitmap(dc, rect, true);
1048 }
1049
1050 int row = flags & wxCONTROL_PRESSED
1051 ? 1
1052 : 0;
1053 int col = flags & wxCONTROL_CHECKED
1054 ? 0
1055 : ( flags & wxCONTROL_UNDETERMINED
1056 ? 2
1057 : 1 );
1058
1059 return m_bitmapsCheckbox[row][col];
1060}
1061
1062void wxMonoRenderer::DrawCheckButton(wxDC& dc,
1063 const wxString& label,
1064 const wxBitmap& bitmapOrig,
1065 const wxRect& rectTotal,
1066 int flags,
1067 wxAlignment align,
1068 int indexAccel)
1069{
1070 wxBitmap bitmap;
1071 if ( bitmapOrig.Ok() )
1072 {
1073 bitmap = bitmapOrig;
1074 }
1075 else
1076 {
1077 bitmap = GetCheckBitmap(flags);
1078 }
1079
1080 DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
1081 flags, align, indexAccel);
1082}
1083
1084void wxMonoRenderer::DoDrawCheckOrRadioBitmap(wxDC& dc,
1085 const wxString& label,
1086 const wxBitmap& bitmap,
1087 const wxRect& rectTotal,
1088 int flags,
1089 wxAlignment align,
1090 int indexAccel)
1091{
1092 wxRect rect = rectTotal;
1093
1094 if ( flags & wxCONTROL_FOCUSED )
1095 {
1096 // draw the focus border around everything
1097 DrawRect(dc, &rect, m_penBlack);
1098 }
1099 else
1100 {
1101 // the border does not offset the string under Mono
1102 rect.Inflate(-1);
1103 }
1104
1105 // calculate the position of the bitmap and of the label
1106 wxCoord xBmp,
1107 yBmp = rect.y + (rect.height - bitmap.GetHeight()) / 2;
1108
1109 wxRect rectLabel;
1110 dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
1111 rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
1112
1113 if ( align == wxALIGN_RIGHT )
1114 {
1115 xBmp = rect.GetRight() - bitmap.GetWidth();
1116 rectLabel.x = rect.x + 2;
1117 rectLabel.SetRight(xBmp);
1118 }
1119 else // normal (checkbox to the left of the text) case
1120 {
1121 xBmp = rect.x + 2;
1122 rectLabel.x = xBmp + bitmap.GetWidth() + 4;
1123 rectLabel.SetRight(rect.GetRight());
1124 }
1125
1126 dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
1127
1128 DrawLabel(dc, label, rectLabel, flags,
1129 wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, indexAccel);
1130}
1131
1132void wxMonoRenderer::DrawRadioButton(wxDC& dc,
1133 const wxString& label,
1134 const wxBitmap& bitmapOrig,
1135 const wxRect& rectTotal,
1136 int flags,
1137 wxAlignment align,
1138 int indexAccel)
1139{
1140 wxBitmap bitmap;
1141 if ( bitmapOrig.Ok() )
1142 {
1143 bitmap = bitmapOrig;
1144 }
1145 else
1146 {
1147 wxRect rect;
1148 wxSize size = GetRadioBitmapSize();
1149 rect.width = size.x;
1150 rect.height = size.y;
1151 bitmap.Create(rect.width, rect.height);
1152 wxMemoryDC dc;
1153 dc.SelectObject(bitmap);
1154 dc.SetBackground(*wxLIGHT_GREY_BRUSH);
1155 dc.Clear();
1156 DrawRadioBitmap(dc, rect, flags);
1157
1158 // must unselect the bitmap before setting a mask for it because of the
1159 // MSW limitations
1160 dc.SelectObject(wxNullBitmap);
1161 bitmap.SetMask(new wxMask(bitmap, *wxLIGHT_GREY));
1162 }
1163
1164 DoDrawCheckOrRadioBitmap(dc, label, bitmap, rectTotal,
1165 flags, align, indexAccel);
1166}
1167
1168#if wxUSE_TOOLBAR
1169void wxMonoRenderer::DrawToolBarButton(wxDC& dc,
1170 const wxString& label,
1171 const wxBitmap& bitmap,
1172 const wxRect& rectOrig,
1173 int flags,
1174 long WXUNUSED(style),
1175 int tbarStyle)
1176{
1177 // we don't draw the separators at all
1178 if ( !label.empty() || bitmap.Ok() )
1179 {
1180 wxRect rect = rectOrig;
1181 rect.Deflate(BORDER_THICKNESS);
1182
1183 if ( flags & wxCONTROL_PRESSED )
1184 {
1185 DrawBorder(dc, wxBORDER_SUNKEN, rect, flags, &rect);
1186
1187 DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_PRESSED), rect);
1188 }
1189 else if ( flags & wxCONTROL_CURRENT )
1190 {
1191 DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rect);
1192
1193 DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL_CURRENT), rect);
1194 }
1195
1196 if(tbarStyle & wxTB_TEXT)
1197 {
1198 if(tbarStyle & wxTB_HORIZONTAL)
1199 {
1200 dc.DrawLabel(label, bitmap, rect, wxALIGN_CENTRE);
1201 }
1202 else
1203 {
1204 dc.DrawLabel(label, bitmap, rect, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL);
1205 }
1206 }
1207 else
1208 {
1209 int xpoint = (rect.GetLeft() + rect.GetRight() + 1 - bitmap.GetWidth()) / 2;
1210 int ypoint = (rect.GetTop() + rect.GetBottom() + 1 - bitmap.GetHeight()) / 2;
1211 dc.DrawBitmap(bitmap, xpoint, ypoint);
1212 }
1213 }
1214}
1215#endif // wxUSE_TOOLBAR
1216
1217// ----------------------------------------------------------------------------
1218// text control
1219// ----------------------------------------------------------------------------
1220
1221#if wxUSE_TEXTCTRL
1222
1223wxRect wxMonoRenderer::GetTextTotalArea(const wxTextCtrl * WXUNUSED(text),
1224 const wxRect& rect) const
1225{
1226 wxRect rectTotal = rect;
1227 rectTotal.Inflate(2*BORDER_THICKNESS);
1228 return rectTotal;
1229}
1230
1231wxRect wxMonoRenderer::GetTextClientArea(const wxTextCtrl *text,
1232 const wxRect& rect,
1233 wxCoord *extraSpaceBeyond) const
1234{
1235 wxRect rectText = rect;
1236 rectText.Deflate(2*BORDER_THICKNESS);
1237
1238 return rectText;
1239}
1240
1241void wxMonoRenderer::DrawTextLine(wxDC& dc,
1242 const wxString& text,
1243 const wxRect& rect,
1244 int selStart,
1245 int selEnd,
1246 int flags)
1247{
1248 StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
1249}
1250
1251void
1252wxMonoRenderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
1253 const wxRect& WXUNUSED(rect))
1254{
1255 // no line wrapping indicators
1256}
1257
1258#endif // wxUSE_TEXTCTRL
1259
1260// ----------------------------------------------------------------------------
1261// combobox
1262// ----------------------------------------------------------------------------
1263
1264#if wxUSE_COMBOBOX
1265
1266void wxMonoRenderer::InitComboBitmaps()
1267{
1268 wxSize sizeArrow = m_sizeScrollbarArrow;
1269 sizeArrow.x -= 2;
1270 sizeArrow.y -= 2;
1271
1272 size_t n;
1273
1274 for ( n = ComboState_Normal; n < ComboState_Max; n++ )
1275 {
1276 m_bitmapsCombo[n].Create(sizeArrow.x, sizeArrow.y);
1277 }
1278
1279 static const int comboButtonFlags[ComboState_Max] =
1280 {
1281 0,
1282 wxCONTROL_CURRENT,
1283 wxCONTROL_PRESSED,
1284 wxCONTROL_DISABLED,
1285 };
1286
1287 wxRect rect(sizeArrow);
1288
1289 wxMemoryDC dc;
1290 for ( n = ComboState_Normal; n < ComboState_Max; n++ )
1291 {
1292 int flags = comboButtonFlags[n];
1293
1294 dc.SelectObject(m_bitmapsCombo[n]);
1295 DoDrawBackground(dc, GetBackgroundColour(flags), rect);
1296 DrawArrow(dc, wxDOWN, rect, flags);
1297 }
1298}
1299
1300void wxMonoRenderer::GetComboBitmaps(wxBitmap *bmpNormal,
1301 wxBitmap *bmpFocus,
1302 wxBitmap *bmpPressed,
1303 wxBitmap *bmpDisabled)
1304{
1305 if ( !m_bitmapsCombo[ComboState_Normal].Ok() )
1306 {
1307 InitComboBitmaps();
1308 }
1309
1310 if ( bmpNormal )
1311 *bmpNormal = m_bitmapsCombo[ComboState_Normal];
1312 if ( bmpFocus )
1313 *bmpFocus = m_bitmapsCombo[ComboState_Focus];
1314 if ( bmpPressed )
1315 *bmpPressed = m_bitmapsCombo[ComboState_Pressed];
1316 if ( bmpDisabled )
1317 *bmpDisabled = m_bitmapsCombo[ComboState_Disabled];
1318}
1319
1320#endif // wxUSE_COMBOBOX
1321
1322// ----------------------------------------------------------------------------
1323// background
1324// ----------------------------------------------------------------------------
1325
1326void wxMonoRenderer::DoDrawBackground(wxDC& dc,
1327 const wxColour& col,
1328 const wxRect& rect,
1329 wxWindow * WXUNUSED(window))
1330{
1331 wxBrush brush(col, wxSOLID);
1332 dc.SetBrush(brush);
1333 dc.SetPen(*wxTRANSPARENT_PEN);
1334 dc.DrawRectangle(rect);
1335}
1336
1337void wxMonoRenderer::DrawBackground(wxDC& dc,
1338 const wxColour& col,
1339 const wxRect& rect,
1340 int WXUNUSED(flags),
1341 wxWindow *window)
1342{
1343}
1344
1345// ----------------------------------------------------------------------------
1346// scrollbar
1347// ----------------------------------------------------------------------------
1348
1349void wxMonoRenderer::DrawArrowBorder(wxDC& dc,
1350 wxRect *rect,
1351 wxDirection dir)
1352{
1353 static const wxDirection sides[] =
1354 {
1355 wxUP, wxLEFT, wxRIGHT, wxDOWN
1356 };
1357
1358 wxRect rect1, rect2, rectInner;
1359 rect1 =
1360 rect2 =
1361 rectInner = *rect;
1362
1363 rect2.Inflate(-1);
1364 rectInner.Inflate(-2);
1365
1366 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), *rect);
1367
1368 // find the side not to draw and also adjust the rectangles to compensate
1369 // for it
1370 wxDirection sideToOmit;
1371 switch ( dir )
1372 {
1373 case wxUP:
1374 sideToOmit = wxDOWN;
1375 rect2.height += 1;
1376 rectInner.height += 1;
1377 break;
1378
1379 case wxDOWN:
1380 sideToOmit = wxUP;
1381 rect2.y -= 1;
1382 rect2.height += 1;
1383 rectInner.y -= 2;
1384 rectInner.height += 1;
1385 break;
1386
1387 case wxLEFT:
1388 sideToOmit = wxRIGHT;
1389 rect2.width += 1;
1390 rectInner.width += 1;
1391 break;
1392
1393 case wxRIGHT:
1394 sideToOmit = wxLEFT;
1395 rect2.x -= 1;
1396 rect2.width += 1;
1397 rectInner.x -= 2;
1398 rectInner.width += 1;
1399 break;
1400
1401 default:
1402 wxFAIL_MSG(_T("unknown arrow direction"));
1403 return;
1404 }
1405
1406 // the outer rect first
1407 size_t n;
1408 for ( n = 0; n < WXSIZEOF(sides); n++ )
1409 {
1410 wxDirection side = sides[n];
1411 if ( side == sideToOmit )
1412 continue;
1413
1414 DrawAntiShadedRectSide(dc, rect1, m_penDarkGrey, m_penHighlight, side);
1415 }
1416
1417 // and then the inner one
1418 for ( n = 0; n < WXSIZEOF(sides); n++ )
1419 {
1420 wxDirection side = sides[n];
1421 if ( side == sideToOmit )
1422 continue;
1423
1424 DrawAntiShadedRectSide(dc, rect2, m_penBlack, m_penGrey, side);
1425 }
1426
1427 *rect = rectInner;
1428}
1429
1430void wxMonoRenderer::DrawScrollbarArrow(wxDC& dc,
1431 wxDirection dir,
1432 const wxRect& rectArrow,
1433 int flags)
1434{
1435 // first of all, draw the border around it - but we don't want the border
1436 // on the side opposite to the arrow point
1437 wxRect rect = rectArrow;
1438 DrawArrowBorder(dc, &rect, dir);
1439
1440 // then the arrow itself
1441 DrawArrow(dc, dir, rect, flags);
1442}
1443
1444// gtk_default_draw_arrow() takes ~350 lines and we can't do much better here
1445// these people are just crazy :-(
1446void wxMonoRenderer::DrawArrow(wxDC& dc,
1447 wxDirection dir,
1448 const wxRect& rect,
1449 int flags)
1450{
1451 enum
1452 {
1453 Point_First,
1454 Point_Second,
1455 Point_Third,
1456 Point_Max
1457 };
1458
1459 wxPoint ptArrow[Point_Max];
1460
1461 wxColour colInside = GetBackgroundColour(flags);
1462 wxPen penShadow[4];
1463 if ( flags & wxCONTROL_DISABLED )
1464 {
1465 penShadow[0] = m_penDarkGrey;
1466 penShadow[1] = m_penDarkGrey;
1467 penShadow[2] = wxNullPen;
1468 penShadow[3] = wxNullPen;
1469 }
1470 else if ( flags & wxCONTROL_PRESSED )
1471 {
1472 penShadow[0] = m_penDarkGrey;
1473 penShadow[1] = m_penHighlight;
1474 penShadow[2] = wxNullPen;
1475 penShadow[3] = m_penBlack;
1476 }
1477 else // normal arrow
1478 {
1479 penShadow[0] = m_penHighlight;
1480 penShadow[1] = m_penBlack;
1481 penShadow[2] = m_penDarkGrey;
1482 penShadow[3] = wxNullPen;
1483 }
1484
1485 wxCoord middle;
1486 if ( dir == wxUP || dir == wxDOWN )
1487 {
1488 // horz middle
1489 middle = (rect.GetRight() + rect.GetLeft() + 1) / 2;
1490 }
1491 else // horz arrow
1492 {
1493 middle = (rect.GetTop() + rect.GetBottom() + 1) / 2;
1494 }
1495
1496 // draw the arrow interior
1497 dc.SetPen(*wxTRANSPARENT_PEN);
1498 dc.SetBrush(wxBrush(colInside, wxSOLID));
1499
1500 switch ( dir )
1501 {
1502 case wxUP:
1503 ptArrow[Point_First].x = rect.GetLeft();
1504 ptArrow[Point_First].y = rect.GetBottom();
1505 ptArrow[Point_Second].x = middle;
1506 ptArrow[Point_Second].y = rect.GetTop();
1507 ptArrow[Point_Third].x = rect.GetRight();
1508 ptArrow[Point_Third].y = rect.GetBottom();
1509 break;
1510
1511 case wxDOWN:
1512 ptArrow[Point_First] = rect.GetPosition();
1513 ptArrow[Point_Second].x = middle;
1514 ptArrow[Point_Second].y = rect.GetBottom();
1515 ptArrow[Point_Third].x = rect.GetRight();
1516 ptArrow[Point_Third].y = rect.GetTop();
1517 break;
1518
1519 case wxLEFT:
1520 ptArrow[Point_First].x = rect.GetRight();
1521 ptArrow[Point_First].y = rect.GetTop();
1522 ptArrow[Point_Second].x = rect.GetLeft();
1523 ptArrow[Point_Second].y = middle;
1524 ptArrow[Point_Third].x = rect.GetRight();
1525 ptArrow[Point_Third].y = rect.GetBottom();
1526 break;
1527
1528 case wxRIGHT:
1529 ptArrow[Point_First] = rect.GetPosition();
1530 ptArrow[Point_Second].x = rect.GetRight();
1531 ptArrow[Point_Second].y = middle;
1532 ptArrow[Point_Third].x = rect.GetLeft();
1533 ptArrow[Point_Third].y = rect.GetBottom();
1534 break;
1535
1536 default:
1537 wxFAIL_MSG(_T("unknown arrow direction"));
1538 }
1539
1540 dc.DrawPolygon(WXSIZEOF(ptArrow), ptArrow);
1541
1542 // draw the arrow border
1543 dc.SetPen(penShadow[0]);
1544 switch ( dir )
1545 {
1546 case wxUP:
1547 dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
1548 dc.DrawPoint(ptArrow[Point_First]);
1549 if ( penShadow[3].Ok() )
1550 {
1551 dc.SetPen(penShadow[3]);
1552 dc.DrawLine(ptArrow[Point_First].x + 1, ptArrow[Point_First].y,
1553 ptArrow[Point_Second].x, ptArrow[Point_Second].y);
1554 }
1555 dc.SetPen(penShadow[1]);
1556 dc.DrawLine(ptArrow[Point_Second].x + 1, ptArrow[Point_Second].y + 1,
1557 ptArrow[Point_Third].x, ptArrow[Point_Third].y);
1558 dc.DrawPoint(ptArrow[Point_Third]);
1559 dc.DrawLine(ptArrow[Point_Third].x - 2, ptArrow[Point_Third].y,
1560 ptArrow[Point_First].x + 1, ptArrow[Point_First].y);
1561 if ( penShadow[2].Ok() )
1562 {
1563 dc.SetPen(penShadow[2]);
1564 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,
1565 ptArrow[Point_Second].x, ptArrow[Point_Second].y + 1);
1566 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y - 1,
1567 ptArrow[Point_First].x + 2, ptArrow[Point_First].y - 1);
1568 }
1569 break;
1570
1571 case wxDOWN:
1572 dc.DrawLine(ptArrow[Point_First], ptArrow[Point_Second]);
1573 dc.DrawLine(ptArrow[Point_First].x + 2, ptArrow[Point_First].y,
1574 ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y);
1575 if ( penShadow[2].Ok() )
1576 {
1577 dc.SetPen(penShadow[2]);
1578 dc.DrawLine(ptArrow[Point_Second].x, ptArrow[Point_Second].y - 1,
1579 ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y - 1);
1580 }
1581 dc.SetPen(penShadow[1]);
1582 dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_Third]);
1583 dc.DrawPoint(ptArrow[Point_Third]);
1584 break;
1585
1586 case wxLEFT:
1587 dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_First]);
1588 dc.DrawPoint(ptArrow[Point_First]);
1589 if ( penShadow[2].Ok() )
1590 {
1591 dc.SetPen(penShadow[2]);
1592 dc.DrawLine(ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y,
1593 ptArrow[Point_First].x - 1, ptArrow[Point_First].y + 2);
1594 dc.DrawLine(ptArrow[Point_Third].x, ptArrow[Point_Third].y,
1595 ptArrow[Point_Second].x + 2, ptArrow[Point_Second].y + 1);
1596 }
1597 dc.SetPen(penShadow[1]);
1598 dc.DrawLine(ptArrow[Point_Third].x, ptArrow[Point_Third].y,
1599 ptArrow[Point_First].x, ptArrow[Point_First].y + 1);
1600 dc.DrawLine(ptArrow[Point_Second].x + 1, ptArrow[Point_Second].y + 1,
1601 ptArrow[Point_Third].x - 1, ptArrow[Point_Third].y);
1602 break;
1603
1604 case wxRIGHT:
1605 dc.DrawLine(ptArrow[Point_First], ptArrow[Point_Third]);
1606 dc.DrawLine(ptArrow[Point_First].x + 2, ptArrow[Point_First].y + 1,
1607 ptArrow[Point_Second].x, ptArrow[Point_Second].y);
1608 dc.SetPen(penShadow[1]);
1609 dc.DrawLine(ptArrow[Point_Second], ptArrow[Point_Third]);
1610 dc.DrawPoint(ptArrow[Point_Third]);
1611 break;
1612
1613 default:
1614 wxFAIL_MSG(_T("unknown arrow direction"));
1615 return;
1616 }
1617}
1618
1619void wxMonoRenderer::DrawThumbBorder(wxDC& dc,
1620 wxRect *rect,
1621 wxOrientation orient)
1622{
1623 if ( orient == wxVERTICAL )
1624 {
1625 DrawAntiShadedRectSide(dc, *rect, m_penDarkGrey, m_penHighlight,
1626 wxLEFT);
1627 DrawAntiShadedRectSide(dc, *rect, m_penDarkGrey, m_penHighlight,
1628 wxRIGHT);
1629 rect->Inflate(-1, 0);
1630
1631 DrawAntiShadedRectSide(dc, *rect, m_penBlack, m_penGrey,
1632 wxLEFT);
1633 DrawAntiShadedRectSide(dc, *rect, m_penBlack, m_penGrey,
1634 wxRIGHT);
1635 rect->Inflate(-1, 0);
1636 }
1637 else
1638 {
1639 DrawAntiShadedRectSide(dc, *rect, m_penDarkGrey, m_penHighlight,
1640 wxUP);
1641 DrawAntiShadedRectSide(dc, *rect, m_penDarkGrey, m_penHighlight,
1642 wxDOWN);
1643 rect->Inflate(0, -1);
1644
1645 DrawAntiShadedRectSide(dc, *rect, m_penBlack, m_penGrey,
1646 wxUP);
1647 DrawAntiShadedRectSide(dc, *rect, m_penBlack, m_penGrey,
1648 wxDOWN);
1649 rect->Inflate(0, -1);
1650 }
1651}
1652
1653void wxMonoRenderer::DrawScrollbarThumb(wxDC& dc,
1654 wxOrientation orient,
1655 const wxRect& rect,
1656 int flags)
1657{
1658 // the thumb is never pressed never has focus border under Mono and the
1659 // scrollbar background never changes at all
1660 int flagsThumb = flags & ~(wxCONTROL_PRESSED | wxCONTROL_FOCUSED);
1661
1662 // we don't want the border in the direction of the scrollbar movement
1663 wxRect rectThumb = rect;
1664 DrawThumbBorder(dc, &rectThumb, orient);
1665
1666 DrawButtonBorder(dc, rectThumb, flagsThumb, &rectThumb);
1667 DrawBackground(dc, wxNullColour, rectThumb, flagsThumb);
1668}
1669
1670void wxMonoRenderer::DrawScrollbarShaft(wxDC& dc,
1671 wxOrientation orient,
1672 const wxRect& rect,
1673 int WXUNUSED(flags))
1674{
1675 wxRect rectBar = rect;
1676 DrawThumbBorder(dc, &rectBar, orient);
1677 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, SCROLLBAR), rectBar);
1678}
1679
1680void wxMonoRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
1681{
1682 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
1683}
1684
1685#if wxUSE_SCROLLBAR
1686wxRect wxMonoRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
1687 wxScrollBar::Element elem,
1688 int thumbPos) const
1689{
1690 // as Mono scrollbars can't be disabled, it makes no sense to remove the
1691 // thumb for a scrollbar with range 0 - instead, make it fill the entire
1692 // scrollbar shaft
1693 if ( (elem == wxScrollBar::Element_Thumb) && !scrollbar->GetRange() )
1694 {
1695 elem = wxScrollBar::Element_Bar_2;
1696 }
1697
1698 return StandardGetScrollbarRect(scrollbar, elem,
1699 thumbPos,
1700 GetScrollbarArrowSize(scrollbar));
1701}
1702
1703wxCoord wxMonoRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
1704{
1705 return StandardScrollBarSize(scrollbar, GetScrollbarArrowSize(scrollbar));
1706}
1707
1708wxHitTest wxMonoRenderer::HitTestScrollbar(const wxScrollBar *scrollbar,
1709 const wxPoint& pt) const
1710{
1711 return StandardHitTestScrollbar(scrollbar, pt,
1712 GetScrollbarArrowSize(scrollbar));
1713}
1714
1715wxCoord wxMonoRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
1716 int thumbPos)
1717{
1718 return StandardScrollbarToPixel(scrollbar, thumbPos,
1719 GetScrollbarArrowSize(scrollbar));
1720}
1721
1722int wxMonoRenderer::PixelToScrollbar(const wxScrollBar *scrollbar,
1723 wxCoord coord)
1724{
1725 return StandardPixelToScrollbar(scrollbar, coord,
1726 GetScrollbarArrowSize(scrollbar));
1727}
1728#endif // wxUSE_SCROLLBAR
1729
1730// ----------------------------------------------------------------------------
1731// size adjustments
1732// ----------------------------------------------------------------------------
1733
1734void wxMonoRenderer::AdjustSize(wxSize *size, const wxWindow *window)
1735{
1736#if wxUSE_BMPBUTTON
1737 if ( wxDynamicCast(window, wxBitmapButton) )
1738 {
1739 size->x += 4;
1740 size->y += 4;
1741 } else
1742#endif // wxUSE_BMPBUTTON
1743#if wxUSE_BUTTON || wxUSE_TOGGLEBTN
1744 if ( 0
1745# if wxUSE_BUTTON
1746 || wxDynamicCast(window, wxButton)
1747# endif // wxUSE_BUTTON
1748# if wxUSE_TOGGLEBTN
1749 || wxDynamicCast(window, wxToggleButton)
1750# endif // wxUSE_TOGGLEBTN
1751 )
1752 {
1753 if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
1754 {
1755 // TODO: this is ad hoc...
1756 size->x += 3*window->GetCharWidth();
1757 wxCoord minBtnHeight = 18;
1758 if ( size->y < minBtnHeight )
1759 size->y = minBtnHeight;
1760
1761 // button border width
1762 size->y += 4;
1763 }
1764 } else
1765#endif // wxUSE_BUTTON || wxUSE_TOGGLEBTN
1766#if wxUSE_SCROLLBAR
1767 if ( wxDynamicCast(window, wxScrollBar) )
1768 {
1769 // we only set the width of vert scrollbars and height of the
1770 // horizontal ones
1771 if ( window->GetWindowStyle() & wxSB_HORIZONTAL )
1772 size->y = m_sizeScrollbarArrow.x;
1773 else
1774 size->x = m_sizeScrollbarArrow.x;
1775 }
1776 else
1777#endif // wxUSE_SCROLLBAR
1778 {
1779 // take into account the border width
1780 wxRect rectBorder = GetBorderDimensions(window->GetBorder());
1781 size->x += rectBorder.x + rectBorder.width;
1782 size->y += rectBorder.y + rectBorder.height;
1783 }
1784}
1785
1786// ----------------------------------------------------------------------------
1787// top level windows
1788// ----------------------------------------------------------------------------
1789
1790void wxMonoRenderer::DrawFrameTitleBar(wxDC& WXUNUSED(dc),
1791 const wxRect& WXUNUSED(rect),
1792 const wxString& WXUNUSED(title),
1793 const wxIcon& WXUNUSED(icon),
1794 int WXUNUSED(flags),
1795 int WXUNUSED(specialButton),
1796 int WXUNUSED(specialButtonFlag))
1797{
1798}
1799
1800void wxMonoRenderer::DrawFrameBorder(wxDC& WXUNUSED(dc),
1801 const wxRect& WXUNUSED(rect),
1802 int WXUNUSED(flags))
1803{
1804}
1805
1806void wxMonoRenderer::DrawFrameBackground(wxDC& WXUNUSED(dc),
1807 const wxRect& WXUNUSED(rect),
1808 int WXUNUSED(flags))
1809{
1810}
1811
1812void wxMonoRenderer::DrawFrameTitle(wxDC& WXUNUSED(dc),
1813 const wxRect& WXUNUSED(rect),
1814 const wxString& WXUNUSED(title),
1815 int WXUNUSED(flags))
1816{
1817}
1818
1819void wxMonoRenderer::DrawFrameIcon(wxDC& WXUNUSED(dc),
1820 const wxRect& WXUNUSED(rect),
1821 const wxIcon& WXUNUSED(icon),
1822 int WXUNUSED(flags))
1823{
1824}
1825
1826void wxMonoRenderer::DrawFrameButton(wxDC& WXUNUSED(dc),
1827 wxCoord WXUNUSED(x),
1828 wxCoord WXUNUSED(y),
1829 int WXUNUSED(button),
1830 int WXUNUSED(flags))
1831{
1832}
1833
1834wxRect
1835wxMonoRenderer::GetFrameClientArea(const wxRect& rect,
1836 int WXUNUSED(flags)) const
1837{
1838 return rect;
1839}
1840
1841wxSize
1842wxMonoRenderer::GetFrameTotalSize(const wxSize& clientSize,
1843 int WXUNUSED(flags)) const
1844{
1845 return clientSize;
1846}
1847
1848wxSize wxMonoRenderer::GetFrameMinSize(int WXUNUSED(flags)) const
1849{
1850 return wxSize(0,0);
1851}
1852
1853wxSize wxMonoRenderer::GetFrameIconSize() const
1854{
1855 return wxSize(wxDefaultCoord, wxDefaultCoord);
1856}
1857
1858int
1859wxMonoRenderer::HitTestFrame(const wxRect& WXUNUSED(rect),
1860 const wxPoint& WXUNUSED(pt),
1861 int WXUNUSED(flags)) const
1862{
1863 return wxHT_TOPLEVEL_CLIENT_AREA;
1864}
1865
1866
1867// ----------------------------------------------------------------------------
1868// standard icons
1869// ----------------------------------------------------------------------------
1870
1871/* Copyright (c) Julian Smart */
1872static const char *error_xpm[] = {
1873/* columns rows colors chars-per-pixel */
1874"48 48 4 1",
1875" c None",
1876"X c #242424",
1877"o c #DCDF00",
1878". c #C00000",
1879/* pixels */
1880" ",
1881" ",
1882" ",
1883" ",
1884" ",
1885" ..... ",
1886" ............. ",
1887" ................. ",
1888" ................... ",
1889" ....................... ",
1890" ......................... ",
1891" ........................... ",
1892" ...........................X ",
1893" .............................X ",
1894" ............................... ",
1895" ...............................X ",
1896" .................................X ",
1897" .................................X ",
1898" .................................XX ",
1899" ...ooooooooooooooooooooooooooo...XX ",
1900" ....ooooooooooooooooooooooooooo....X ",
1901" ....ooooooooooooooooooooooooooo....X ",
1902" ....ooooooooooooooooooooooooooo....XX ",
1903" ....ooooooooooooooooooooooooooo....XX ",
1904" ....ooooooooooooooooooooooooooo....XX ",
1905" ...ooooooooooooooooooooooooooo...XXX ",
1906" ...ooooooooooooooooooooooooooo...XXX ",
1907" .................................XX ",
1908" .................................XX ",
1909" ...............................XXX ",
1910" ...............................XXX ",
1911" .............................XXX ",
1912" ...........................XXXX ",
1913" ...........................XXX ",
1914" .........................XXX ",
1915" .......................XXXX ",
1916" X...................XXXXX ",
1917" X.................XXXXX ",
1918" X.............XXXXX ",
1919" XXXX.....XXXXXXXX ",
1920" XXXXXXXXXXXXX ",
1921" XXXXX ",
1922" ",
1923" ",
1924" ",
1925" ",
1926" ",
1927" "
1928};
1929
1930/* Copyright (c) Julian Smart */
1931static const char *info_xpm[] = {
1932/* columns rows colors chars-per-pixel */
1933"48 48 9 1",
1934"$ c Black",
1935"O c #FFFFFF",
1936"@ c #808080",
1937"+ c #000080",
1938"o c #E8EB01",
1939" c None",
1940"X c #FFFF40",
1941"# c #C0C0C0",
1942". c #ABAD01",
1943/* pixels */
1944" ",
1945" ",
1946" ",
1947" ",
1948" ",
1949" ",
1950" ",
1951" ",
1952" ",
1953" ..... ",
1954" ..XXXXX.. ",
1955" ..XXXXXXXXo.. ",
1956" .XXXOXXXXXXXoo. ",
1957" .XOOXXX+XXXXXo. ",
1958" .XOOOXX+++XXXXoo. ",
1959" .XOOXXX+++XXXXXo. ",
1960" .XOOOXXX+++XXXXXXo. ",
1961" .XOOXXXX+++XXXXXXo. ",
1962" .XXXXXXX+++XXXXXXX. ",
1963" .XXXXXXX+++XXXXXXo. ",
1964" .XXXXXXX+++XXXXXoo. ",
1965" .XXXXXX+++XXXXXo. ",
1966" .XXXXXXX+XXXXXXo. ",
1967" .XXXXXXXXXXXXo. ",
1968" .XXXXX+++XXXoo. ",
1969" .XXXX+++XXoo. ",
1970" .XXXXXXXXo. ",
1971" ..XXXXXXo.. ",
1972" .XXXXXo.. ",
1973" @#######@ ",
1974" @@@@@@@@@ ",
1975" @#######@ ",
1976" @@@@@@@@@ ",
1977" @#######@ ",
1978" @@@@@@@ ",
1979" ### ",
1980" $$$ ",
1981" ",
1982" ",
1983" ",
1984" ",
1985" ",
1986" ",
1987" ",
1988" ",
1989" ",
1990" ",
1991" "
1992};
1993
1994/* Copyright (c) Julian Smart */
1995static const char *warning_xpm[] = {
1996/* columns rows colors chars-per-pixel */
1997"48 48 9 1",
1998"@ c Black",
1999"o c #A6A800",
2000"+ c #8A8C00",
2001"$ c #B8BA00",
2002" c None",
2003"O c #6E7000",
2004"X c #DCDF00",
2005". c #C00000",
2006"# c #373800",
2007/* pixels */
2008" ",
2009" ",
2010" ",
2011" ",
2012" ",
2013" ",
2014" ",
2015" . ",
2016" ... ",
2017" ... ",
2018" ..... ",
2019" ...X.. ",
2020" ..XXX.. ",
2021" ...XXX... ",
2022" ..XXXXX.. ",
2023" ..XXXXXX... ",
2024" ...XXoO+XX.. ",
2025" ..XXXO@#XXX.. ",
2026" ..XXXXO@#XXX... ",
2027" ...XXXXO@#XXXX.. ",
2028" ..XXXXXO@#XXXX... ",
2029" ...XXXXXo@OXXXXX.. ",
2030" ...XXXXXXo@OXXXXXX.. ",
2031" ..XXXXXXX$@OXXXXXX... ",
2032" ...XXXXXXXX@XXXXXXXX.. ",
2033" ...XXXXXXXXXXXXXXXXXX... ",
2034" ..XXXXXXXXXXOXXXXXXXXX.. ",
2035" ...XXXXXXXXXO@#XXXXXXXXX.. ",
2036" ..XXXXXXXXXXX#XXXXXXXXXX... ",
2037" ...XXXXXXXXXXXXXXXXXXXXXXX.. ",
2038" ...XXXXXXXXXXXXXXXXXXXXXXXX... ",
2039" .............................. ",
2040" .............................. ",
2041" ",
2042" ",
2043" ",
2044" ",
2045" ",
2046" ",
2047" ",
2048" ",
2049" ",
2050" ",
2051" ",
2052" ",
2053" ",
2054" ",
2055" "
2056};
2057
2058/* Copyright (c) Julian Smart */
2059static const char *question_xpm[] = {
2060/* columns rows colors chars-per-pixel */
2061"48 48 21 1",
2062". c Black",
2063"> c #696969",
2064"O c #1F1F00",
2065"+ c #181818",
2066"o c #F6F900",
2067"; c #3F3F00",
2068"$ c #111111",
2069" c None",
2070"& c #202020",
2071"X c #AAAA00",
2072"@ c #949400",
2073": c #303030",
2074"1 c #383838",
2075"% c #2A2A00",
2076", c #404040",
2077"= c #B4B400",
2078"- c #484848",
2079"# c #151500",
2080"< c #9F9F00",
2081"2 c #6A6A00",
2082"* c #353500",
2083/* pixels */
2084" ",
2085" ",
2086" ",
2087" ",
2088" ......... ",
2089" ...XXXXXXX.. ",
2090" ..XXXXoooooXXXO+ ",
2091" ..XXooooooooooooX@.. ",
2092" ..XoooooooooooooooXX#. ",
2093" $%XoooooooooooooooooXX#. ",
2094" &.XoooooooXXXXXXooooooXX.. ",
2095" .XooooooXX.$...$XXoooooX*. ",
2096" $.XoooooX%.$ .*oooooo=.. ",
2097" .XooooooX.. -.XoooooX.. ",
2098" .XoooooX..+ .XoooooX;. ",
2099" ...XXXX..: .XoooooX;. ",
2100" ........ >.XoooooX;. ",
2101" +.XoooooX.. ",
2102" ,.Xoooooo<.. ",
2103" 1#XooooooXO.. ",
2104" &#XooooooX2.. ",
2105" $%XooooooXX.. ",
2106" $%XooooooXX.. ",
2107" $%XooooooXX.. ",
2108" &.XooooooXX.. ",
2109" .XooooooXX.. ",
2110" &.XoooooXX.. ",
2111" ..XooooXX.. ",
2112" ..XooooX... ",
2113" ..XXooXX..& ",
2114" ...XXXXX.. ",
2115" ........ ",
2116" ",
2117" ",
2118" ....... ",
2119" ..XXXXX.. ",
2120" ..XXoooXX.. ",
2121" ..XoooooX.. ",
2122" ..XoooooX.. ",
2123" ..XXoooXX.. ",
2124" ..XXXXX.. ",
2125" ....... ",
2126" ",
2127" ",
2128" ",
2129" ",
2130" ",
2131" "
2132};
2133
2134wxBitmap wxMonoArtProvider::CreateBitmap(const wxArtID& id,
2135 const wxArtClient& WXUNUSED(client),
2136 const wxSize& WXUNUSED(size))
2137{
2138 if ( id == wxART_INFORMATION )
2139 return wxBitmap(info_xpm);
2140 if ( id == wxART_ERROR )
2141 return wxBitmap(error_xpm);
2142 if ( id == wxART_WARNING )
2143 return wxBitmap(warning_xpm);
2144 if ( id == wxART_QUESTION )
2145 return wxBitmap(question_xpm);
2146 return wxNullBitmap;
2147}
2148
2149
2150// ============================================================================
2151// wxInputHandler
2152// ============================================================================
2153
wxWidgets (Impactor)