]> git.saurik.com Git - wxWidgets.git/blob - src/univ/themes/win32.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't set min width for the buttons
[wxWidgets.git] / src / univ / themes / win32.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: univ/themes/win32.cpp
3 // Purpose: wxUniversal theme implementing Win32-like LNF
4 // Author: Vadim Zeitlin
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 license
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 #include "wx/timer.h"
29 #include "wx/intl.h"
30 #include "wx/dc.h"
31 #include "wx/window.h"
32
33 #include "wx/dcmemory.h"
34
35 #include "wx/button.h"
36 #include "wx/listbox.h"
37 #include "wx/checklst.h"
38 #include "wx/combobox.h"
39 #include "wx/scrolbar.h"
40 #include "wx/slider.h"
41 #include "wx/textctrl.h"
42 #endif // WX_PRECOMP
43
44 #include "wx/notebook.h"
45 #include "wx/spinbutt.h"
46 #include "wx/settings.h"
47 #include "wx/menu.h"
48
49 #include "wx/univ/scrtimer.h"
50
51 #include "wx/univ/renderer.h"
52 #include "wx/univ/inphand.h"
53 #include "wx/univ/colschem.h"
54 #include "wx/univ/theme.h"
55
56 // ----------------------------------------------------------------------------
57 // constants
58 // ----------------------------------------------------------------------------
59
60 static const int BORDER_THICKNESS = 2;
61
62 // the offset between the label and focus rect around it
63 static const int FOCUS_RECT_OFFSET_X = 1;
64 static const int FOCUS_RECT_OFFSET_Y = 1;
65
66 enum IndicatorType
67 {
68 IndicatorType_Check,
69 IndicatorType_Radio,
70 IndicatorType_Menu,
71 IndicatorType_Max
72 };
73
74 enum IndicatorState
75 {
76 IndicatorState_Normal,
77 IndicatorState_Pressed, // this one is for check/radioboxes
78 IndicatorState_Selected = IndicatorState_Pressed, // for menus
79 IndicatorState_Disabled,
80 IndicatorState_SelectedDisabled, // only for the menus
81 IndicatorState_Max
82 };
83
84 enum IndicatorStatus
85 {
86 IndicatorStatus_Checked,
87 IndicatorStatus_Unchecked,
88 IndicatorStatus_Max
89 };
90
91 // wxWin32Renderer: draw the GUI elements in Win32 style
92 // ----------------------------------------------------------------------------
93
94 class wxWin32Renderer : public wxRenderer
95 {
96 public:
97 // constants
98 enum wxArrowDirection
99 {
100 Arrow_Left,
101 Arrow_Right,
102 Arrow_Up,
103 Arrow_Down,
104 Arrow_Max
105 };
106
107 enum wxArrowStyle
108 {
109 Arrow_Normal,
110 Arrow_Disabled,
111 Arrow_Pressed,
112 Arrow_Inversed,
113 Arrow_InversedDisabled,
114 Arrow_StateMax
115 };
116
117 // ctor
118 wxWin32Renderer(const wxColourScheme *scheme);
119
120 // implement the base class pure virtuals
121 virtual void DrawBackground(wxDC& dc,
122 const wxColour& col,
123 const wxRect& rect,
124 int flags = 0);
125 virtual void DrawLabel(wxDC& dc,
126 const wxString& label,
127 const wxRect& rect,
128 int flags = 0,
129 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
130 int indexAccel = -1,
131 wxRect *rectBounds = NULL);
132 virtual void DrawButtonLabel(wxDC& dc,
133 const wxString& label,
134 const wxBitmap& image,
135 const wxRect& rect,
136 int flags = 0,
137 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
138 int indexAccel = -1,
139 wxRect *rectBounds = NULL);
140 virtual void DrawBorder(wxDC& dc,
141 wxBorder border,
142 const wxRect& rect,
143 int flags = 0,
144 wxRect *rectIn = (wxRect *)NULL);
145 virtual void DrawHorizontalLine(wxDC& dc,
146 wxCoord y, wxCoord x1, wxCoord x2);
147 virtual void DrawVerticalLine(wxDC& dc,
148 wxCoord x, wxCoord y1, wxCoord y2);
149 virtual void DrawFrame(wxDC& dc,
150 const wxString& label,
151 const wxRect& rect,
152 int flags = 0,
153 int alignment = wxALIGN_LEFT,
154 int indexAccel = -1);
155 virtual void DrawTextBorder(wxDC& dc,
156 wxBorder border,
157 const wxRect& rect,
158 int flags = 0,
159 wxRect *rectIn = (wxRect *)NULL);
160 virtual void DrawButtonBorder(wxDC& dc,
161 const wxRect& rect,
162 int flags = 0,
163 wxRect *rectIn = (wxRect *)NULL);
164 virtual void DrawArrow(wxDC& dc,
165 wxDirection dir,
166 const wxRect& rect,
167 int flags = 0);
168 virtual void DrawScrollbarArrow(wxDC& dc,
169 wxDirection dir,
170 const wxRect& rect,
171 int flags = 0)
172 { DrawArrow(dc, dir, rect, flags); }
173 virtual void DrawScrollbarThumb(wxDC& dc,
174 wxOrientation orient,
175 const wxRect& rect,
176 int flags = 0);
177 virtual void DrawScrollbarShaft(wxDC& dc,
178 wxOrientation orient,
179 const wxRect& rect,
180 int flags = 0);
181 virtual void DrawScrollCorner(wxDC& dc,
182 const wxRect& rect);
183 virtual void DrawItem(wxDC& dc,
184 const wxString& label,
185 const wxRect& rect,
186 int flags = 0);
187 virtual void DrawCheckItem(wxDC& dc,
188 const wxString& label,
189 const wxBitmap& bitmap,
190 const wxRect& rect,
191 int flags = 0);
192 virtual void DrawCheckButton(wxDC& dc,
193 const wxString& label,
194 const wxBitmap& bitmap,
195 const wxRect& rect,
196 int flags = 0,
197 wxAlignment align = wxALIGN_LEFT,
198 int indexAccel = -1);
199 virtual void DrawRadioButton(wxDC& dc,
200 const wxString& label,
201 const wxBitmap& bitmap,
202 const wxRect& rect,
203 int flags = 0,
204 wxAlignment align = wxALIGN_LEFT,
205 int indexAccel = -1);
206 virtual void DrawTextLine(wxDC& dc,
207 const wxString& text,
208 const wxRect& rect,
209 int selStart = -1,
210 int selEnd = -1,
211 int flags = 0);
212 virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
213 virtual void DrawTab(wxDC& dc,
214 const wxRect& rect,
215 wxDirection dir,
216 const wxString& label,
217 const wxBitmap& bitmap = wxNullBitmap,
218 int flags = 0,
219 int indexAccel = -1);
220
221 virtual void DrawSliderShaft(wxDC& dc,
222 const wxRect& rect,
223 wxOrientation orient,
224 int flags = 0,
225 wxRect *rectShaft = NULL);
226 virtual void DrawSliderThumb(wxDC& dc,
227 const wxRect& rect,
228 wxOrientation orient,
229 int flags = 0);
230 virtual void DrawSliderTicks(wxDC& dc,
231 const wxRect& rect,
232 const wxSize& sizeThumb,
233 wxOrientation orient,
234 int start,
235 int end,
236 int step = 1,
237 int flags = 0);
238 #if wxUSE_MENUS
239
240 virtual void DrawMenuBarItem(wxDC& dc,
241 const wxRect& rect,
242 const wxString& label,
243 int flags = 0,
244 int indexAccel = -1);
245 virtual void DrawMenuItem(wxDC& dc,
246 wxCoord y,
247 const wxMenuGeometryInfo& geometryInfo,
248 const wxString& label,
249 const wxString& accel,
250 const wxBitmap& bitmap = wxNullBitmap,
251 int flags = 0,
252 int indexAccel = -1);
253 virtual void DrawMenuSeparator(wxDC& dc,
254 wxCoord y,
255 const wxMenuGeometryInfo& geomInfo);
256 #endif
257 virtual void GetComboBitmaps(wxBitmap *bmpNormal,
258 wxBitmap *bmpPressed,
259 wxBitmap *bmpDisabled);
260
261 virtual void AdjustSize(wxSize *size, const wxWindow *window);
262 virtual wxRect GetBorderDimensions(wxBorder border) const;
263 virtual bool AreScrollbarsInsideBorder() const;
264
265 virtual wxSize GetScrollbarArrowSize() const
266 { return m_sizeScrollbarArrow; }
267 virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
268 wxScrollBar::Element elem,
269 int thumbPos = -1) const;
270 virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
271 virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
272 const wxPoint& pt) const;
273 virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
274 int thumbPos = -1);
275 virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
276 virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
277 { return fontHeight + 2; }
278 virtual wxSize GetCheckBitmapSize() const
279 { return wxSize(13, 13); }
280 virtual wxSize GetRadioBitmapSize() const
281 { return wxSize(12, 12); }
282 virtual wxCoord GetCheckItemMargin() const
283 { return 0; }
284
285 virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
286 const wxRect& rect);
287 virtual wxRect GetTextClientArea(const wxTextCtrl *text,
288 const wxRect& rect,
289 wxCoord *extraSpaceBeyond);
290
291 virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
292 virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
293
294 virtual wxCoord GetSliderDim() const { return 20; }
295 virtual wxCoord GetSliderTickLen() const { return 4; }
296 virtual wxRect GetSliderShaftRect(const wxRect& rect,
297 wxOrientation orient) const;
298 virtual wxSize GetSliderThumbSize(const wxRect& rect,
299 wxOrientation orient) const;
300 virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
301
302 #if wxUSE_MENUS
303 virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
304 virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
305 const wxMenu& menu) const;
306 #endif
307 protected:
308 // helper of DrawLabel() and DrawCheckOrRadioButton()
309 void DoDrawLabel(wxDC& dc,
310 const wxString& label,
311 const wxRect& rect,
312 int flags = 0,
313 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
314 int indexAccel = -1,
315 wxRect *rectBounds = NULL,
316 const wxPoint& focusOffset
317 = wxPoint(FOCUS_RECT_OFFSET_X, FOCUS_RECT_OFFSET_Y));
318
319 // common part of DrawLabel() and DrawItem()
320 void DrawFocusRect(wxDC& dc, const wxRect& rect);
321
322 // DrawLabel() and DrawButtonLabel() helper
323 void DrawLabelShadow(wxDC& dc,
324 const wxString& label,
325 const wxRect& rect,
326 int alignment,
327 int indexAccel);
328
329 // DrawButtonBorder() helper
330 void DoDrawBackground(wxDC& dc,
331 const wxColour& col,
332 const wxRect& rect);
333
334 // DrawBorder() helpers: all of them shift and clip the DC after drawing
335 // the border
336
337 // just draw a rectangle with the given pen
338 void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
339
340 // draw the lower left part of rectangle
341 void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
342
343 // draw the rectange using the first brush for the left and top sides and
344 // the second one for the bottom and right ones
345 void DrawShadedRect(wxDC& dc, wxRect *rect,
346 const wxPen& pen1, const wxPen& pen2);
347
348 // draw the normal 3D border
349 void DrawRaisedBorder(wxDC& dc, wxRect *rect);
350
351 // draw the sunken 3D border
352 void DrawSunkenBorder(wxDC& dc, wxRect *rect);
353
354 // draw the border used for scrollbar arrows
355 void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
356
357 // public DrawArrow()s helper
358 void DrawArrow(wxDC& dc, const wxRect& rect,
359 wxArrowDirection arrowDir, wxArrowStyle arrowStyle);
360
361 // DrawArrowButton is used by DrawScrollbar and DrawComboButton
362 void DrawArrowButton(wxDC& dc, const wxRect& rect,
363 wxArrowDirection arrowDir,
364 wxArrowStyle arrowStyle);
365
366 // DrawCheckButton/DrawRadioButton helper
367 void DrawCheckOrRadioButton(wxDC& dc,
368 const wxString& label,
369 const wxBitmap& bitmap,
370 const wxRect& rect,
371 int flags,
372 wxAlignment align,
373 int indexAccel,
374 wxCoord focusOffsetY);
375
376 // draw a normal or transposed line (useful for using the same code fo both
377 // horizontal and vertical widgets)
378 void DrawLine(wxDC& dc,
379 wxCoord x1, wxCoord y1,
380 wxCoord x2, wxCoord y2,
381 bool transpose = FALSE)
382 {
383 if ( transpose )
384 dc.DrawLine(y1, x1, y2, x2);
385 else
386 dc.DrawLine(x1, y1, x2, y2);
387 }
388
389 // get the standard check/radio button bitmap
390 wxBitmap GetIndicator(IndicatorType indType, int flags);
391 wxBitmap GetCheckBitmap(int flags)
392 { return GetIndicator(IndicatorType_Check, flags); }
393 wxBitmap GetRadioBitmap(int flags)
394 { return GetIndicator(IndicatorType_Radio, flags); }
395
396 private:
397 const wxColourScheme *m_scheme;
398
399 // the sizing parameters (TODO make them changeable)
400 wxSize m_sizeScrollbarArrow;
401
402 // GDI objects we use for drawing
403 wxColour m_colDarkGrey,
404 m_colHighlight;
405
406 wxPen m_penBlack,
407 m_penDarkGrey,
408 m_penLightGrey,
409 m_penHighlight;
410
411 // first row is for the normal state, second - for the disabled
412 wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
413 };
414
415 // ----------------------------------------------------------------------------
416 // wxWin32InputHandler and derived classes: process the keyboard and mouse
417 // messages according to Windows standards
418 // ----------------------------------------------------------------------------
419
420 class wxWin32InputHandler : public wxInputHandler
421 {
422 public:
423 wxWin32InputHandler(wxWin32Renderer *renderer);
424
425 virtual bool HandleKey(wxControl *control,
426 const wxKeyEvent& event,
427 bool pressed);
428 virtual bool HandleMouse(wxControl *control,
429 const wxMouseEvent& event);
430
431 protected:
432 wxWin32Renderer *m_renderer;
433 };
434
435 class wxWin32ScrollBarInputHandler : public wxStdScrollBarInputHandler
436 {
437 public:
438 wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
439 wxInputHandler *handler);
440
441 virtual bool HandleMouse(wxControl *control, const wxMouseEvent& event);
442 virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
443
444 virtual bool OnScrollTimer(wxScrollBar *scrollbar,
445 const wxControlAction& action);
446
447 protected:
448 virtual bool IsAllowedButton(int button) { return button == 1; }
449
450 virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
451 {
452 // we don't highlight anything
453 }
454
455 // the first and last event which caused the thumb to move
456 wxMouseEvent m_eventStartDrag,
457 m_eventLastDrag;
458
459 // have we paused the scrolling because the mouse moved?
460 bool m_scrollPaused;
461
462 // we remember the interval of the timer to be able to restart it
463 int m_interval;
464 };
465
466 class wxWin32CheckboxInputHandler : public wxStdCheckboxInputHandler
467 {
468 public:
469 wxWin32CheckboxInputHandler(wxInputHandler *handler)
470 : wxStdCheckboxInputHandler(handler) { }
471
472 virtual bool HandleKey(wxControl *control,
473 const wxKeyEvent& event,
474 bool pressed);
475 };
476
477 class wxWin32TextCtrlInputHandler : public wxStdTextCtrlInputHandler
478 {
479 public:
480 wxWin32TextCtrlInputHandler(wxInputHandler *handler)
481 : wxStdTextCtrlInputHandler(handler) { }
482
483 virtual bool HandleKey(wxControl *control,
484 const wxKeyEvent& event,
485 bool pressed);
486 };
487
488 // ----------------------------------------------------------------------------
489 // wxWin32ColourScheme: uses (default) Win32 colours
490 // ----------------------------------------------------------------------------
491
492 class wxWin32ColourScheme : public wxColourScheme
493 {
494 public:
495 virtual wxColour Get(StdColour col) const;
496 virtual wxColour GetBackground(wxWindow *win) const;
497 };
498
499 // ----------------------------------------------------------------------------
500 // wxWin32Theme
501 // ----------------------------------------------------------------------------
502
503 WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
504
505 class wxWin32Theme : public wxTheme
506 {
507 public:
508 wxWin32Theme();
509 virtual ~wxWin32Theme();
510
511 virtual wxRenderer *GetRenderer() { return m_renderer; }
512 virtual wxInputHandler *GetInputHandler(const wxString& control);
513 virtual wxColourScheme *GetColourScheme();
514
515 private:
516 // get the default input handler
517 wxInputHandler *GetDefaultInputHandler();
518
519 wxWin32Renderer *m_renderer;
520
521 // the names of the already created handlers and the handlers themselves
522 // (these arrays are synchronized)
523 wxSortedArrayString m_handlerNames;
524 wxArrayHandlers m_handlers;
525
526 wxWin32InputHandler *m_handlerDefault;
527
528 wxWin32ColourScheme *m_scheme;
529
530 WX_DECLARE_THEME(win32)
531 };
532
533 // ----------------------------------------------------------------------------
534 // standard bitmaps
535 // ----------------------------------------------------------------------------
536
537 // menu bitmaps
538
539 static const char *checked_menu_xpm[] = {
540 /* columns rows colors chars-per-pixel */
541 "9 9 2 1",
542 "w c None",
543 "b c black",
544 /* pixels */
545 "wwwwwwwww",
546 "wwwwwwwbw",
547 "wwwwwwbbw",
548 "wbwwwbbbw",
549 "wbbwbbbww",
550 "wbbbbbwww",
551 "wwbbbwwww",
552 "wwwbwwwww",
553 "wwwwwwwww"
554 };
555
556 static const char *selected_checked_menu_xpm[] = {
557 /* columns rows colors chars-per-pixel */
558 "9 9 2 1",
559 "w c None",
560 "b c white",
561 /* pixels */
562 "wwwwwwwww",
563 "wwwwwwwbw",
564 "wwwwwwbbw",
565 "wbwwwbbbw",
566 "wbbwbbbww",
567 "wbbbbbwww",
568 "wwbbbwwww",
569 "wwwbwwwww",
570 "wwwwwwwww"
571 };
572
573 static const char *disabled_checked_menu_xpm[] = {
574 /* columns rows colors chars-per-pixel */
575 "9 9 3 1",
576 "w c None",
577 "b c #7f7f7f",
578 "W c #e0e0e0",
579 /* pixels */
580 "wwwwwwwww",
581 "wwwwwwwbw",
582 "wwwwwwbbW",
583 "wbwwwbbbW",
584 "wbbwbbbWW",
585 "wbbbbbWWw",
586 "wwbbbWWww",
587 "wwwbWWwww",
588 "wwwwWwwww"
589 };
590
591 static const char *selected_disabled_checked_menu_xpm[] = {
592 /* columns rows colors chars-per-pixel */
593 "9 9 2 1",
594 "w c None",
595 "b c #7f7f7f",
596 /* pixels */
597 "wwwwwwwww",
598 "wwwwwwwbw",
599 "wwwwwwbbw",
600 "wbwwwbbbw",
601 "wbbwbbbww",
602 "wbbbbbwww",
603 "wwbbbwwww",
604 "wwwbwwwww",
605 "wwwwwwwww"
606 };
607
608 // checkbox and radiobox bitmaps below
609
610 static const char *checked_xpm[] = {
611 /* columns rows colors chars-per-pixel */
612 "13 13 5 1",
613 "w c white",
614 "b c black",
615 "d c #7f7f7f",
616 "g c #c0c0c0",
617 "h c #e0e0e0",
618 /* pixels */
619 "ddddddddddddh",
620 "dbbbbbbbbbbgh",
621 "dbwwwwwwwwwgh",
622 "dbwwwwwwwbwgh",
623 "dbwwwwwwbbwgh",
624 "dbwbwwwbbbwgh",
625 "dbwbbwbbbwwgh",
626 "dbwbbbbbwwwgh",
627 "dbwwbbbwwwwgh",
628 "dbwwwbwwwwwgh",
629 "dbwwwwwwwwwgh",
630 "dgggggggggggh",
631 "hhhhhhhhhhhhh"
632 };
633
634 static const char *pressed_checked_xpm[] = {
635 /* columns rows colors chars-per-pixel */
636 "13 13 4 1",
637 "b c black",
638 "d c #7f7f7f",
639 "g c #c0c0c0",
640 "h c #e0e0e0",
641 /* pixels */
642 "ddddddddddddh",
643 "dbbbbbbbbbbgh",
644 "dbggggggggggh",
645 "dbgggggggbggh",
646 "dbggggggbbggh",
647 "dbgbgggbbbggh",
648 "dbgbbgbbbgggh",
649 "dbgbbbbbggggh",
650 "dbggbbbgggggh",
651 "dbgggbggggggh",
652 "dbggggggggggh",
653 "dgggggggggggh",
654 "hhhhhhhhhhhhh"
655 };
656
657 static const char *pressed_disabled_checked_xpm[] = {
658 /* columns rows colors chars-per-pixel */
659 "13 13 4 1",
660 "b c black",
661 "d c #7f7f7f",
662 "g c #c0c0c0",
663 "h c #e0e0e0",
664 /* pixels */
665 "ddddddddddddh",
666 "dbbbbbbbbbbgh",
667 "dbggggggggggh",
668 "dbgggggggdggh",
669 "dbggggggddggh",
670 "dbgdgggdddggh",
671 "dbgddgdddgggh",
672 "dbgdddddggggh",
673 "dbggdddgggggh",
674 "dbgggdggggggh",
675 "dbggggggggggh",
676 "dgggggggggggh",
677 "hhhhhhhhhhhhh"
678 };
679
680 static const char *checked_item_xpm[] = {
681 /* columns rows colors chars-per-pixel */
682 "13 13 3 1",
683 "w c white",
684 "b c black",
685 "d c #808080",
686 /* pixels */
687 "wwwwwwwwwwwww",
688 "wdddddddddddw",
689 "wdwwwwwwwwwdw",
690 "wdwwwwwwwbwdw",
691 "wdwwwwwwbbwdw",
692 "wdwbwwwbbbwdw",
693 "wdwbbwbbbwwdw",
694 "wdwbbbbbwwwdw",
695 "wdwwbbbwwwwdw",
696 "wdwwwbwwwwwdw",
697 "wdwwwwwwwwwdw",
698 "wdddddddddddw",
699 "wwwwwwwwwwwww"
700 };
701
702 static const char *unchecked_xpm[] = {
703 /* columns rows colors chars-per-pixel */
704 "13 13 5 1",
705 "w c white",
706 "b c black",
707 "d c #7f7f7f",
708 "g c #c0c0c0",
709 "h c #e0e0e0",
710 /* pixels */
711 "ddddddddddddh",
712 "dbbbbbbbbbbgh",
713 "dbwwwwwwwwwgh",
714 "dbwwwwwwwwwgh",
715 "dbwwwwwwwwwgh",
716 "dbwwwwwwwwwgh",
717 "dbwwwwwwwwwgh",
718 "dbwwwwwwwwwgh",
719 "dbwwwwwwwwwgh",
720 "dbwwwwwwwwwgh",
721 "dbwwwwwwwwwgh",
722 "dgggggggggggh",
723 "hhhhhhhhhhhhh"
724 };
725
726 static const char *pressed_unchecked_xpm[] = {
727 /* columns rows colors chars-per-pixel */
728 "13 13 4 1",
729 "b c black",
730 "d c #7f7f7f",
731 "g c #c0c0c0",
732 "h c #e0e0e0",
733 /* pixels */
734 "ddddddddddddh",
735 "dbbbbbbbbbbgh",
736 "dbggggggggggh",
737 "dbggggggggggh",
738 "dbggggggggggh",
739 "dbggggggggggh",
740 "dbggggggggggh",
741 "dbggggggggggh",
742 "dbggggggggggh",
743 "dbggggggggggh",
744 "dbggggggggggh",
745 "dbggggggggggh",
746 "hhhhhhhhhhhhh"
747 };
748
749 static const char *unchecked_item_xpm[] = {
750 /* columns rows colors chars-per-pixel */
751 "13 13 2 1",
752 "w c white",
753 "d c #808080",
754 /* pixels */
755 "wwwwwwwwwwwww",
756 "wdddddddddddw",
757 "wdwwwwwwwwwdw",
758 "wdwwwwwwwwwdw",
759 "wdwwwwwwwwwdw",
760 "wdwwwwwwwwwdw",
761 "wdwwwwwwwwwdw",
762 "wdwwwwwwwwwdw",
763 "wdwwwwwwwwwdw",
764 "wdwwwwwwwwwdw",
765 "wdwwwwwwwwwdw",
766 "wdddddddddddw",
767 "wwwwwwwwwwwww"
768 };
769
770 static const char *checked_radio_xpm[] = {
771 /* columns rows colors chars-per-pixel */
772 "12 12 6 1",
773 " c None",
774 "w c white",
775 "b c black",
776 "d c #7f7f7f",
777 "g c #c0c0c0",
778 "h c #e0e0e0",
779 /* pixels */
780 " dddd ",
781 " ddbbbbdd ",
782 " dbbwwwwbbh ",
783 " dbwwwwwwgh ",
784 "dbwwwbbwwwgh",
785 "dbwwbbbbwwgh",
786 "dbwwbbbbwwgh",
787 "dbwwwbbwwwgh",
788 " dbwwwwwwgh ",
789 " dggwwwwggh ",
790 " hhgggghh ",
791 " hhhh "
792 };
793
794 static const char *pressed_checked_radio_xpm[] = {
795 /* columns rows colors chars-per-pixel */
796 "12 12 6 1",
797 " c None",
798 "w c white",
799 "b c black",
800 "d c #7f7f7f",
801 "g c #c0c0c0",
802 "h c #e0e0e0",
803 /* pixels */
804 " dddd ",
805 " ddbbbbdd ",
806 " dbbggggbbh ",
807 " dbgggggggh ",
808 "dbgggbbggggh",
809 "dbggbbbbgggh",
810 "dbggbbbbgggh",
811 "dbgggbbggggh",
812 " dbgggggggh ",
813 " dggggggggh ",
814 " hhgggghh ",
815 " hhhh "
816 };
817
818 static const char *pressed_disabled_checked_radio_xpm[] = {
819 /* columns rows colors chars-per-pixel */
820 "12 12 6 1",
821 " c None",
822 "w c white",
823 "b c black",
824 "d c #7f7f7f",
825 "g c #c0c0c0",
826 "h c #e0e0e0",
827 /* pixels */
828 " dddd ",
829 " ddbbbbdd ",
830 " dbbggggbbh ",
831 " dbgggggggh ",
832 "dbgggddggggh",
833 "dbggddddgggh",
834 "dbggddddgggh",
835 "dbgggddggggh",
836 " dbgggggggh ",
837 " dggggggggh ",
838 " hhgggghh ",
839 " hhhh ",
840 };
841
842 static const char *unchecked_radio_xpm[] = {
843 /* columns rows colors chars-per-pixel */
844 "12 12 6 1",
845 " c None",
846 "w c white",
847 "b c black",
848 "d c #7f7f7f",
849 "g c #c0c0c0",
850 "h c #e0e0e0",
851 /* pixels */
852 " dddd ",
853 " ddbbbbdd ",
854 " dbbwwwwbbh ",
855 " dbwwwwwwgh ",
856 "dbwwwwwwwwgh",
857 "dbwwwwwwwwgh",
858 "dbwwwwwwwwgh",
859 "dbwwwwwwwwgh",
860 " dbwwwwwwgh ",
861 " dggwwwwggh ",
862 " hhgggghh ",
863 " hhhh "
864 };
865
866 static const char *pressed_unchecked_radio_xpm[] = {
867 /* columns rows colors chars-per-pixel */
868 "12 12 6 1",
869 " c None",
870 "w c white",
871 "b c black",
872 "d c #7f7f7f",
873 "g c #c0c0c0",
874 "h c #e0e0e0",
875 /* pixels */
876 " dddd ",
877 " ddbbbbdd ",
878 " dbbggggbbh ",
879 " dbgggggggh ",
880 "dbgggggggggh",
881 "dbgggggggggh",
882 "dbgggggggggh",
883 "dbgggggggggh",
884 " dbgggggggh ",
885 " dggggggggh ",
886 " hhgggghh ",
887 " hhhh "
888 };
889
890 static const char **
891 bmpIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
892 {
893 // checkboxes first
894 {
895 // normal state
896 { checked_xpm, unchecked_xpm },
897
898 // pressed state
899 { pressed_checked_xpm, pressed_unchecked_xpm },
900
901 // disabled state
902 { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
903 },
904
905 // radio
906 {
907 // normal state
908 { checked_radio_xpm, unchecked_radio_xpm },
909
910 // pressed state
911 { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
912
913 // disabled state
914 { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
915 },
916
917 // menu
918 {
919 // normal state
920 { checked_menu_xpm, NULL },
921
922 // selected state
923 { selected_checked_menu_xpm, NULL },
924
925 // disabled state
926 { disabled_checked_menu_xpm, NULL },
927
928 // disabled selected state
929 { selected_disabled_checked_menu_xpm, NULL },
930 }
931 };
932
933 // ============================================================================
934 // implementation
935 // ============================================================================
936
937 WX_IMPLEMENT_THEME(wxWin32Theme, win32, wxTRANSLATE("Win32 theme"));
938
939 // ----------------------------------------------------------------------------
940 // wxWin32Theme
941 // ----------------------------------------------------------------------------
942
943 wxWin32Theme::wxWin32Theme()
944 {
945 m_scheme = new wxWin32ColourScheme;
946 m_renderer = new wxWin32Renderer(m_scheme);
947 m_handlerDefault = NULL;
948 }
949
950 wxWin32Theme::~wxWin32Theme()
951 {
952 size_t count = m_handlers.GetCount();
953 for ( size_t n = 0; n < count; n++ )
954 {
955 if ( m_handlers[n] != m_handlerDefault )
956 delete m_handlers[n];
957 }
958
959 delete m_handlerDefault;
960
961 delete m_renderer;
962 delete m_scheme;
963 }
964
965 wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
966 {
967 if ( !m_handlerDefault )
968 {
969 m_handlerDefault = new wxWin32InputHandler(m_renderer);
970 }
971
972 return m_handlerDefault;
973 }
974
975 wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
976 {
977 wxInputHandler *handler;
978 int n = m_handlerNames.Index(control);
979 if ( n == wxNOT_FOUND )
980 {
981 // create a new handler
982 if ( control == wxINP_HANDLER_SCROLLBAR )
983 handler = new wxWin32ScrollBarInputHandler(m_renderer,
984 GetDefaultInputHandler());
985 #if wxUSE_BUTTON
986 else if ( control == wxINP_HANDLER_BUTTON )
987 handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
988 #endif // wxUSE_BUTTON
989 #if wxUSE_CHECKBOX
990 else if ( control == wxINP_HANDLER_CHECKBOX )
991 handler = new wxWin32CheckboxInputHandler(GetDefaultInputHandler());
992 #endif // wxUSE_CHECKBOX
993 #if wxUSE_COMBOBOX
994 else if ( control == wxINP_HANDLER_COMBOBOX )
995 handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
996 #endif // wxUSE_COMBOBOX
997 #if wxUSE_LISTBOX
998 else if ( control == wxINP_HANDLER_LISTBOX )
999 handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
1000 #endif // wxUSE_LISTBOX
1001 #if wxUSE_CHECKLISTBOX
1002 else if ( control == wxINP_HANDLER_CHECKLISTBOX )
1003 handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
1004 #endif // wxUSE_CHECKLISTBOX
1005 #if wxUSE_TEXTCTRL
1006 else if ( control == wxINP_HANDLER_TEXTCTRL )
1007 handler = new wxWin32TextCtrlInputHandler(GetDefaultInputHandler());
1008 #endif // wxUSE_TEXTCTRL
1009 #if wxUSE_SLIDER
1010 else if ( control == wxINP_HANDLER_SLIDER )
1011 handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
1012 #endif // wxUSE_SLIDER
1013 #if wxUSE_SPINBTN
1014 else if ( control == wxINP_HANDLER_SPINBTN )
1015 handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
1016 #endif // wxUSE_SPINBTN
1017 #if wxUSE_NOTEBOOK
1018 else if ( control == wxINP_HANDLER_NOTEBOOK )
1019 handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
1020 #endif // wxUSE_NOTEBOOK
1021 else
1022 handler = GetDefaultInputHandler();
1023
1024 n = m_handlerNames.Add(control);
1025 m_handlers.Insert(handler, n);
1026 }
1027 else // we already have it
1028 {
1029 handler = m_handlers[n];
1030 }
1031
1032 return handler;
1033 }
1034
1035 wxColourScheme *wxWin32Theme::GetColourScheme()
1036 {
1037 return m_scheme;
1038 }
1039
1040 // ============================================================================
1041 // wxWin32ColourScheme
1042 // ============================================================================
1043
1044 wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
1045 {
1046 wxColour col;
1047 if ( win->UseBgCol() )
1048 {
1049 // use the user specified colour
1050 col = win->GetBackgroundColour();
1051 }
1052
1053 if ( win->IsContainerWindow() )
1054 {
1055 wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
1056 if ( text )
1057 {
1058 if ( !text->IsEnabled() ) // not IsEditable()
1059 col = Get(CONTROL);
1060 //else: execute code below
1061 }
1062
1063 if ( !col.Ok() )
1064 {
1065 // doesn't depend on the state
1066 col = Get(WINDOW);
1067 }
1068 }
1069 else
1070 {
1071 int flags = win->GetStateFlags();
1072
1073 // the colour set by the user should be used for the normal state
1074 // and for the states for which we don't have any specific colours
1075 if ( !col.Ok() || (flags != 0) )
1076 {
1077 if ( wxDynamicCast(win, wxScrollBar) )
1078 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
1079 : SCROLLBAR);
1080 else
1081 col = Get(CONTROL);
1082 }
1083 }
1084
1085 return col;
1086 }
1087
1088 wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
1089 {
1090 switch ( col )
1091 {
1092 case WINDOW: return *wxWHITE;
1093
1094 // use the system colours under Windows
1095 #if defined(__WXMSW__)
1096 case WINDOW: return wxColour(GetSysColor(COLOR_WINDOW));
1097
1098 case CONTROL_PRESSED:
1099 case CONTROL_CURRENT:
1100 case CONTROL: return wxColour(GetSysColor(COLOR_BTNFACE));
1101
1102 case CONTROL_TEXT: return wxColour(GetSysColor(COLOR_BTNTEXT));
1103
1104 case SCROLLBAR: return wxColour(GetSysColor(COLOR_SCROLLBAR));
1105 case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
1106
1107 case HIGHLIGHT: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
1108 case HIGHLIGHT_TEXT: return wxColour(GetSysColor(COLOR_HIGHLIGHTTEXT));
1109
1110 #if defined(COLOR_3DDKSHADOW)
1111 case SHADOW_DARK: return wxColour(GetSysColor(COLOR_3DDKSHADOW));
1112 #else
1113 case SHADOW_DARK: return *wxBLACK;
1114 #endif
1115
1116 case CONTROL_TEXT_DISABLED:
1117 case SHADOW_HIGHLIGHT: return wxColour(GetSysColor(COLOR_BTNHIGHLIGHT));
1118
1119 case SHADOW_IN: return wxColour(GetSysColor(COLOR_BTNFACE));
1120
1121 case CONTROL_TEXT_DISABLED_SHADOW:
1122 case SHADOW_OUT: return wxColour(GetSysColor(COLOR_BTNSHADOW));
1123 #else // !__WXMSW__
1124 // use the standard Windows colours elsewhere
1125 case CONTROL_PRESSED:
1126 case CONTROL_CURRENT:
1127 case CONTROL: return wxColour(0xc0c0c0);
1128
1129 case CONTROL_TEXT: return *wxBLACK;
1130
1131 case SCROLLBAR: return wxColour(0xe0e0e0);
1132 case SCROLLBAR_PRESSED: return *wxBLACK;
1133
1134 case HIGHLIGHT: return wxColour(0x800000);
1135 case HIGHLIGHT_TEXT: return wxColour(0xffffff);
1136
1137 case SHADOW_DARK: return *wxBLACK;
1138
1139 case CONTROL_TEXT_DISABLED:
1140 case SHADOW_HIGHLIGHT: return wxColour(0xe0e0e0);
1141
1142 case SHADOW_IN: return wxColour(0xc0c0c0);
1143
1144 case CONTROL_TEXT_DISABLED_SHADOW:
1145 case SHADOW_OUT: return wxColour(0x7f7f7f);
1146 #endif // __WXMSW__
1147
1148 case MAX:
1149 default:
1150 wxFAIL_MSG(_T("invalid standard colour"));
1151 return *wxBLACK;
1152 }
1153 }
1154
1155 // ============================================================================
1156 // wxWin32Renderer
1157 // ============================================================================
1158
1159 // ----------------------------------------------------------------------------
1160 // construction
1161 // ----------------------------------------------------------------------------
1162
1163 wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
1164 {
1165 // init data
1166 m_scheme = scheme;
1167 m_sizeScrollbarArrow = wxSize(16, 16);
1168
1169 // init colours and pens
1170 m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
1171
1172 m_colDarkGrey = wxSCHEME_COLOUR(scheme, SHADOW_OUT);
1173 m_penDarkGrey = wxPen(m_colDarkGrey, 0, wxSOLID);
1174
1175 m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
1176
1177 m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
1178 m_penHighlight = wxPen(m_colHighlight, 0, wxSOLID);
1179
1180 // init the arrow bitmaps
1181 static const size_t ARROW_WIDTH = 7;
1182 static const size_t ARROW_LENGTH = 4;
1183
1184 wxMask *mask;
1185 wxMemoryDC dcNormal,
1186 dcDisabled,
1187 dcInverse;
1188 for ( size_t n = 0; n < Arrow_Max; n++ )
1189 {
1190 bool isVertical = n > Arrow_Right;
1191 int w, h;
1192 if ( isVertical )
1193 {
1194 w = ARROW_WIDTH;
1195 h = ARROW_LENGTH;
1196 }
1197 else
1198 {
1199 h = ARROW_WIDTH;
1200 w = ARROW_LENGTH;
1201 }
1202
1203 // disabled arrow is larger because of the shadow
1204 m_bmpArrows[Arrow_Normal][n].Create(w, h);
1205 m_bmpArrows[Arrow_Disabled][n].Create(w + 1, h + 1);
1206
1207 dcNormal.SelectObject(m_bmpArrows[Arrow_Normal][n]);
1208 dcDisabled.SelectObject(m_bmpArrows[Arrow_Disabled][n]);
1209
1210 dcNormal.SetBackground(*wxWHITE_BRUSH);
1211 dcDisabled.SetBackground(*wxWHITE_BRUSH);
1212 dcNormal.Clear();
1213 dcDisabled.Clear();
1214
1215 dcNormal.SetPen(m_penBlack);
1216 dcDisabled.SetPen(m_penDarkGrey);
1217
1218 // calculate the position of the point of the arrow
1219 wxCoord x1, y1;
1220 if ( isVertical )
1221 {
1222 x1 = (ARROW_WIDTH - 1)/2;
1223 y1 = n == Arrow_Up ? 0 : ARROW_LENGTH - 1;
1224 }
1225 else // horizontal
1226 {
1227 x1 = n == Arrow_Left ? 0 : ARROW_LENGTH - 1;
1228 y1 = (ARROW_WIDTH - 1)/2;
1229 }
1230
1231 wxCoord x2 = x1,
1232 y2 = y1;
1233
1234 if ( isVertical )
1235 x2++;
1236 else
1237 y2++;
1238
1239 for ( size_t i = 0; i < ARROW_LENGTH; i++ )
1240 {
1241 dcNormal.DrawLine(x1, y1, x2, y2);
1242 dcDisabled.DrawLine(x1, y1, x2, y2);
1243
1244 if ( isVertical )
1245 {
1246 x1--;
1247 x2++;
1248
1249 if ( n == Arrow_Up )
1250 {
1251 y1++;
1252 y2++;
1253 }
1254 else // down arrow
1255 {
1256 y1--;
1257 y2--;
1258 }
1259 }
1260 else // left or right arrow
1261 {
1262 y1--;
1263 y2++;
1264
1265 if ( n == Arrow_Left )
1266 {
1267 x1++;
1268 x2++;
1269 }
1270 else
1271 {
1272 x1--;
1273 x2--;
1274 }
1275 }
1276 }
1277
1278 // draw the shadow for the disabled one
1279 dcDisabled.SetPen(m_penHighlight);
1280 switch ( n )
1281 {
1282 case Arrow_Left:
1283 y1 += 2;
1284 dcDisabled.DrawLine(x1, y1, x2, y2);
1285 break;
1286
1287 case Arrow_Right:
1288 x1 = ARROW_LENGTH - 1;
1289 y1 = (ARROW_WIDTH - 1)/2 + 1;
1290 x2 = 0;
1291 y2 = ARROW_WIDTH;
1292 dcDisabled.DrawLine(x1, y1, x2, y2);
1293 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1294 break;
1295
1296 case Arrow_Up:
1297 x1 += 2;
1298 dcDisabled.DrawLine(x1, y1, x2, y2);
1299 break;
1300
1301 case Arrow_Down:
1302 x1 = ARROW_WIDTH - 1;
1303 y1 = 1;
1304 x2 = (ARROW_WIDTH - 1)/2;
1305 y2 = ARROW_LENGTH;
1306 dcDisabled.DrawLine(x1, y1, x2, y2);
1307 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1308 break;
1309
1310 }
1311
1312 // create the inversed bitmap but only for the right arrow as we only
1313 // use it for the menus
1314 if ( n == Arrow_Right )
1315 {
1316 m_bmpArrows[Arrow_Inversed][n].Create(w, h);
1317 dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
1318 dcInverse.Clear();
1319 dcInverse.Blit(0, 0, w, h,
1320 &dcNormal, 0, 0,
1321 wxXOR);
1322 dcInverse.SelectObject(wxNullBitmap);
1323
1324 mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
1325 m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
1326
1327 m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
1328 dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
1329 dcInverse.Clear();
1330 dcInverse.Blit(0, 0, w, h,
1331 &dcDisabled, 0, 0,
1332 wxXOR);
1333 dcInverse.SelectObject(wxNullBitmap);
1334
1335 mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
1336 m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
1337 }
1338
1339 dcNormal.SelectObject(wxNullBitmap);
1340 dcDisabled.SelectObject(wxNullBitmap);
1341
1342 mask = new wxMask(m_bmpArrows[Arrow_Normal][n], *wxWHITE);
1343 m_bmpArrows[Arrow_Normal][n].SetMask(mask);
1344 mask = new wxMask(m_bmpArrows[Arrow_Disabled][n], *wxWHITE);
1345 m_bmpArrows[Arrow_Disabled][n].SetMask(mask);
1346
1347 m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
1348 }
1349 }
1350
1351 // ----------------------------------------------------------------------------
1352 // border stuff
1353 // ----------------------------------------------------------------------------
1354
1355 /*
1356 The raised border in Win32 looks like this:
1357
1358 IIIIIIIIIIIIIIIIIIIIIIB
1359 I GB
1360 I GB I = white (HILIGHT)
1361 I GB H = light grey (LIGHT)
1362 I GB G = dark grey (SHADOI)
1363 I GB B = black (DKSHADOI)
1364 I GB I = hIghlight (COLOR_3DHILIGHT)
1365 I GB
1366 IGGGGGGGGGGGGGGGGGGGGGB
1367 BBBBBBBBBBBBBBBBBBBBBBB
1368
1369 The sunken border looks like this:
1370
1371 GGGGGGGGGGGGGGGGGGGGGGI
1372 GBBBBBBBBBBBBBBBBBBBBHI
1373 GB HI
1374 GB HI
1375 GB HI
1376 GB HI
1377 GB HI
1378 GB HI
1379 GHHHHHHHHHHHHHHHHHHHHHI
1380 IIIIIIIIIIIIIIIIIIIIIII
1381
1382 The static border (used for the controls which don't get focus) is like
1383 this:
1384
1385 GGGGGGGGGGGGGGGGGGGGGGW
1386 G W
1387 G W
1388 G W
1389 G W
1390 G W
1391 G W
1392 G W
1393 WWWWWWWWWWWWWWWWWWWWWWW
1394
1395 The most complicated is the double border:
1396
1397 HHHHHHHHHHHHHHHHHHHHHHB
1398 HWWWWWWWWWWWWWWWWWWWWGB
1399 HWHHHHHHHHHHHHHHHHHHHGB
1400 HWH HGB
1401 HWH HGB
1402 HWH HGB
1403 HWH HGB
1404 HWHHHHHHHHHHHHHHHHHHHGB
1405 HGGGGGGGGGGGGGGGGGGGGGB
1406 BBBBBBBBBBBBBBBBBBBBBBB
1407
1408 And the simple border is, well, simple:
1409
1410 BBBBBBBBBBBBBBBBBBBBBBB
1411 B B
1412 B B
1413 B B
1414 B B
1415 B B
1416 B B
1417 B B
1418 B B
1419 BBBBBBBBBBBBBBBBBBBBBBB
1420 */
1421
1422 void wxWin32Renderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1423 {
1424 // draw
1425 dc.SetPen(pen);
1426 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1427 dc.DrawRectangle(*rect);
1428
1429 // adjust the rect
1430 rect->Inflate(-1);
1431 }
1432
1433 void wxWin32Renderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1434 {
1435 // draw the bottom and right sides
1436 dc.SetPen(pen);
1437 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1438 rect->GetRight() + 1, rect->GetBottom());
1439 dc.DrawLine(rect->GetRight(), rect->GetTop(),
1440 rect->GetRight(), rect->GetBottom());
1441
1442 // adjust the rect
1443 rect->width--;
1444 rect->height--;
1445 }
1446
1447 void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
1448 const wxPen& pen1, const wxPen& pen2)
1449 {
1450 // draw the rectangle
1451 dc.SetPen(pen1);
1452 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
1453 rect->GetLeft(), rect->GetBottom());
1454 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
1455 rect->GetRight(), rect->GetTop());
1456 dc.SetPen(pen2);
1457 dc.DrawLine(rect->GetRight(), rect->GetTop(),
1458 rect->GetRight(), rect->GetBottom());
1459 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1460 rect->GetRight() + 1, rect->GetBottom());
1461
1462 // adjust the rect
1463 rect->Inflate(-1);
1464 }
1465
1466 void wxWin32Renderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
1467 {
1468 DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
1469 DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
1470 }
1471
1472 void wxWin32Renderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
1473 {
1474 DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
1475 DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
1476 }
1477
1478 void wxWin32Renderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
1479 {
1480 if ( isPressed )
1481 {
1482 DrawRect(dc, rect, m_penDarkGrey);
1483
1484 // the arrow is usually drawn inside border of width 2 and is offset by
1485 // another pixel in both directions when it's pressed - as the border
1486 // in this case is more narrow as well, we have to adjust rect like
1487 // this:
1488 rect->Inflate(-1);
1489 rect->x++;
1490 rect->y++;
1491 }
1492 else
1493 {
1494 DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
1495 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
1496 }
1497 }
1498
1499 void wxWin32Renderer::DrawBorder(wxDC& dc,
1500 wxBorder border,
1501 const wxRect& rectTotal,
1502 int WXUNUSED(flags),
1503 wxRect *rectIn)
1504 {
1505 int i;
1506
1507 wxRect rect = rectTotal;
1508
1509 switch ( border )
1510 {
1511 case wxBORDER_SUNKEN:
1512 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1513 {
1514 DrawSunkenBorder(dc, &rect);
1515 }
1516 break;
1517
1518 case wxBORDER_STATIC:
1519 DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
1520 break;
1521
1522 case wxBORDER_RAISED:
1523 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1524 {
1525 DrawRaisedBorder(dc, &rect);
1526 }
1527 break;
1528
1529 case wxBORDER_DOUBLE:
1530 DrawArrowBorder(dc, &rect);
1531 DrawRect(dc, &rect, m_penLightGrey);
1532 break;
1533
1534 case wxBORDER_SIMPLE:
1535 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1536 {
1537 DrawRect(dc, &rect, m_penBlack);
1538 }
1539 break;
1540
1541 default:
1542 wxFAIL_MSG(_T("unknown border type"));
1543 // fall through
1544
1545 case wxBORDER_DEFAULT:
1546 case wxBORDER_NONE:
1547 break;
1548 }
1549
1550 if ( rectIn )
1551 *rectIn = rect;
1552 }
1553
1554 wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
1555 {
1556 wxCoord width;
1557 switch ( border )
1558 {
1559 case wxBORDER_RAISED:
1560 case wxBORDER_SUNKEN:
1561 width = BORDER_THICKNESS;
1562 break;
1563
1564 case wxBORDER_SIMPLE:
1565 case wxBORDER_STATIC:
1566 width = 1;
1567 break;
1568
1569 case wxBORDER_DOUBLE:
1570 width = 3;
1571 break;
1572
1573 default:
1574 wxFAIL_MSG(_T("unknown border type"));
1575 // fall through
1576
1577 case wxBORDER_DEFAULT:
1578 case wxBORDER_NONE:
1579 width = 0;
1580 break;
1581 }
1582
1583 wxRect rect;
1584 rect.x =
1585 rect.y =
1586 rect.width =
1587 rect.height = width;
1588
1589 return rect;
1590 }
1591
1592 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
1593 {
1594 return TRUE;
1595 }
1596
1597 // ----------------------------------------------------------------------------
1598 // borders
1599 // ----------------------------------------------------------------------------
1600
1601 void wxWin32Renderer::DrawTextBorder(wxDC& dc,
1602 wxBorder border,
1603 const wxRect& rect,
1604 int flags,
1605 wxRect *rectIn)
1606 {
1607 // text controls are not special under windows
1608 DrawBorder(dc, border, rect, flags, rectIn);
1609 }
1610
1611 void wxWin32Renderer::DrawButtonBorder(wxDC& dc,
1612 const wxRect& rectTotal,
1613 int flags,
1614 wxRect *rectIn)
1615 {
1616 wxRect rect = rectTotal;
1617
1618 if ( flags & wxCONTROL_PRESSED )
1619 {
1620 // button pressed: draw a double border around it
1621 DrawRect(dc, &rect, m_penBlack);
1622 DrawRect(dc, &rect, m_penDarkGrey);
1623 }
1624 else
1625 {
1626 // button not pressed
1627
1628 if ( flags & (wxCONTROL_FOCUSED | wxCONTROL_ISDEFAULT) )
1629 {
1630 // button either default or focused (or both): add an extra border around it
1631 DrawRect(dc, &rect, m_penBlack);
1632 }
1633
1634 // now draw a normal button
1635 DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
1636 DrawHalfRect(dc, &rect, m_penDarkGrey);
1637 }
1638
1639 if ( rectIn )
1640 {
1641 *rectIn = rect;
1642 }
1643 }
1644
1645 // ----------------------------------------------------------------------------
1646 // lines and frame
1647 // ----------------------------------------------------------------------------
1648
1649 void wxWin32Renderer::DrawHorizontalLine(wxDC& dc,
1650 wxCoord y, wxCoord x1, wxCoord x2)
1651 {
1652 dc.SetPen(m_penDarkGrey);
1653 dc.DrawLine(x1, y, x2 + 1, y);
1654 dc.SetPen(m_penHighlight);
1655 y++;
1656 dc.DrawLine(x1, y, x2 + 1, y);
1657 }
1658
1659 void wxWin32Renderer::DrawVerticalLine(wxDC& dc,
1660 wxCoord x, wxCoord y1, wxCoord y2)
1661 {
1662 dc.SetPen(m_penDarkGrey);
1663 dc.DrawLine(x, y1, x, y2 + 1);
1664 dc.SetPen(m_penHighlight);
1665 x++;
1666 dc.DrawLine(x, y1, x, y2 + 1);
1667 }
1668
1669 void wxWin32Renderer::DrawFrame(wxDC& dc,
1670 const wxString& label,
1671 const wxRect& rect,
1672 int flags,
1673 int alignment,
1674 int indexAccel)
1675 {
1676 wxCoord height = 0; // of the label
1677 wxRect rectFrame = rect;
1678 if ( !label.empty() )
1679 {
1680 // the text should touch the top border of the rect, so the frame
1681 // itself should be lower
1682 dc.GetTextExtent(label, NULL, &height);
1683 rectFrame.y += height / 2;
1684 rectFrame.height -= height / 2;
1685
1686 // we have to draw each part of the frame individually as we can't
1687 // erase the background beyond the label as it might contain some
1688 // pixmap already, so drawing everything and then overwriting part of
1689 // the frame with label doesn't work
1690
1691 // TODO: the +5 and space insertion should be customizable
1692
1693 wxRect rectText;
1694 rectText.x = rectFrame.x + 5;
1695 rectText.y = rect.y;
1696 rectText.width = rectFrame.width - 7; // +2 border width
1697 rectText.height = height;
1698
1699 wxString label2;
1700 label2 << _T(' ') << label << _T(' ');
1701 if ( indexAccel != -1 )
1702 {
1703 // adjust it as we prepended a space
1704 indexAccel++;
1705 }
1706
1707 wxRect rectLabel;
1708 DrawLabel(dc, label2, rectText, flags, alignment, indexAccel, &rectLabel);
1709
1710 StandardDrawFrame(dc, rectFrame, rectLabel);
1711 }
1712 else
1713 {
1714 // just draw the complete frame
1715 DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
1716 DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
1717 }
1718 }
1719
1720 // ----------------------------------------------------------------------------
1721 // label
1722 // ----------------------------------------------------------------------------
1723
1724 void wxWin32Renderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
1725 {
1726 // VZ: this doesn't work under Windows, the dotted pen has dots of 3
1727 // pixels each while we really need dots here... PS_ALTERNATE might
1728 // work, but it is for NT 5 only
1729 #if 0
1730 DrawRect(dc, &rect, wxPen(*wxBLACK, 0, wxDOT));
1731 #else
1732 // draw the pixels manually: note that to behave in the same manner as
1733 // DrawRect(), we must exclude the bottom and right borders from the
1734 // rectangle
1735 wxCoord x1 = rect.GetLeft(),
1736 y1 = rect.GetTop(),
1737 x2 = rect.GetRight(),
1738 y2 = rect.GetBottom();
1739
1740 dc.SetPen(wxPen(*wxBLACK, 0, wxSOLID));
1741
1742 // this seems to be closer than what Windows does than wxINVERT although
1743 // I'm still not sure if it's correct
1744 dc.SetLogicalFunction(wxAND_REVERSE);
1745
1746 wxCoord z;
1747 for ( z = x1 + 1; z < x2; z += 2 )
1748 dc.DrawPoint(z, rect.GetTop());
1749
1750 wxCoord shift = z == x2 ? 0 : 1;
1751 for ( z = y1 + shift; z < y2; z += 2 )
1752 dc.DrawPoint(x2, z);
1753
1754 shift = z == y2 ? 0 : 1;
1755 for ( z = x2 - shift; z > x1; z -= 2 )
1756 dc.DrawPoint(z, y2);
1757
1758 shift = z == x1 ? 0 : 1;
1759 for ( z = y2 - shift; z > y1; z -= 2 )
1760 dc.DrawPoint(x1, z);
1761
1762 dc.SetLogicalFunction(wxCOPY);
1763 #endif // 0/1
1764 }
1765
1766 void wxWin32Renderer::DrawLabelShadow(wxDC& dc,
1767 const wxString& label,
1768 const wxRect& rect,
1769 int alignment,
1770 int indexAccel)
1771 {
1772 // draw shadow of the text
1773 dc.SetTextForeground(m_colHighlight);
1774 wxRect rectShadow = rect;
1775 rectShadow.x++;
1776 rectShadow.y++;
1777 dc.DrawLabel(label, rectShadow, alignment, indexAccel);
1778
1779 // make the text grey
1780 dc.SetTextForeground(m_colDarkGrey);
1781 }
1782
1783 void wxWin32Renderer::DrawLabel(wxDC& dc,
1784 const wxString& label,
1785 const wxRect& rect,
1786 int flags,
1787 int alignment,
1788 int indexAccel,
1789 wxRect *rectBounds)
1790 {
1791 DoDrawLabel(dc, label, rect, flags, alignment, indexAccel, rectBounds);
1792 }
1793
1794 void wxWin32Renderer::DoDrawLabel(wxDC& dc,
1795 const wxString& label,
1796 const wxRect& rect,
1797 int flags,
1798 int alignment,
1799 int indexAccel,
1800 wxRect *rectBounds,
1801 const wxPoint& focusOffset)
1802 {
1803 // the underscores are not drawn for focused controls in wxMSW
1804 if ( flags & wxCONTROL_FOCUSED )
1805 {
1806 indexAccel = -1;
1807 }
1808
1809 if ( flags & wxCONTROL_DISABLED )
1810 {
1811 // the combination of wxCONTROL_SELECTED and wxCONTROL_DISABLED
1812 // currently only can happen for a menu item and it seems that Windows
1813 // doesn't draw the shadow in this case, so we don't do it neither
1814 if ( flags & wxCONTROL_SELECTED )
1815 {
1816 // just make the label text greyed out
1817 dc.SetTextForeground(m_colDarkGrey);
1818 }
1819 else // draw normal disabled label
1820 {
1821 DrawLabelShadow(dc, label, rect, alignment, indexAccel);
1822 }
1823 }
1824
1825 wxRect rectLabel;
1826 dc.DrawLabel(label, wxNullBitmap, rect, alignment, indexAccel, &rectLabel);
1827
1828 if ( flags & wxCONTROL_DISABLED )
1829 {
1830 // restore the fg colour
1831 dc.SetTextForeground(*wxBLACK);
1832 }
1833
1834 if ( flags & wxCONTROL_FOCUSED )
1835 {
1836 if ( focusOffset.x || focusOffset.y )
1837 {
1838 rectLabel.Inflate(focusOffset.x, focusOffset.y);
1839 }
1840
1841 DrawFocusRect(dc, rectLabel);
1842 }
1843
1844 if ( rectBounds )
1845 *rectBounds = rectLabel;
1846 }
1847
1848 void wxWin32Renderer::DrawButtonLabel(wxDC& dc,
1849 const wxString& label,
1850 const wxBitmap& image,
1851 const wxRect& rect,
1852 int flags,
1853 int alignment,
1854 int indexAccel,
1855 wxRect *rectBounds)
1856 {
1857 // the underscores are not drawn for focused controls in wxMSW
1858 if ( flags & wxCONTROL_PRESSED )
1859 {
1860 indexAccel = -1;
1861 }
1862
1863 wxRect rectLabel = rect;
1864 if ( !label.empty() )
1865 {
1866 // shift the label if a button is pressed
1867 if ( flags & wxCONTROL_PRESSED )
1868 {
1869 rectLabel.x++;
1870 rectLabel.y++;
1871 }
1872
1873 if ( flags & wxCONTROL_DISABLED )
1874 {
1875 DrawLabelShadow(dc, label, rectLabel, alignment, indexAccel);
1876 }
1877
1878 // leave enough space for the focus rectangle
1879 if ( flags & wxCONTROL_FOCUSED )
1880 {
1881 rectLabel.Inflate(-2);
1882 }
1883 }
1884
1885 dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
1886
1887 if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
1888 {
1889 if ( flags & wxCONTROL_PRESSED )
1890 {
1891 // the focus rectangle is never pressed, so undo the shift done
1892 // above
1893 rectLabel.x--;
1894 rectLabel.y--;
1895 rectLabel.width--;
1896 rectLabel.height--;
1897 }
1898
1899 DrawFocusRect(dc, rectLabel);
1900 }
1901 }
1902
1903 // ----------------------------------------------------------------------------
1904 // (check)listbox items
1905 // ----------------------------------------------------------------------------
1906
1907 void wxWin32Renderer::DrawItem(wxDC& dc,
1908 const wxString& label,
1909 const wxRect& rect,
1910 int flags)
1911 {
1912 wxDCTextColourChanger colChanger(dc);
1913
1914 if ( flags & wxCONTROL_SELECTED )
1915 {
1916 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
1917
1918 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
1919 dc.SetBrush(wxBrush(colBg, wxSOLID));
1920 dc.SetPen(wxPen(colBg, 0, wxSOLID));
1921 dc.DrawRectangle(rect);
1922 }
1923
1924 wxRect rectText = rect;
1925 rectText.x += 2;
1926 rectText.width -= 2;
1927 dc.DrawLabel(label, wxNullBitmap, rectText);
1928
1929 if ( flags & wxCONTROL_FOCUSED )
1930 {
1931 DrawFocusRect(dc, rect);
1932 }
1933 }
1934
1935 void wxWin32Renderer::DrawCheckItem(wxDC& dc,
1936 const wxString& label,
1937 const wxBitmap& bitmap,
1938 const wxRect& rect,
1939 int flags)
1940 {
1941 wxBitmap bmp;
1942 if ( bitmap.Ok() )
1943 {
1944 bmp = bitmap;
1945 }
1946 else // use default bitmap
1947 {
1948 bmp = wxBitmap(flags & wxCONTROL_CHECKED ? checked_item_xpm
1949 : unchecked_item_xpm);
1950 }
1951
1952 dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
1953 TRUE /* use mask */);
1954
1955 wxRect rectLabel = rect;
1956 int bmpWidth = bmp.GetWidth();
1957 rectLabel.x += bmpWidth;
1958 rectLabel.width -= bmpWidth;
1959
1960 DrawItem(dc, label, rectLabel, flags);
1961 }
1962
1963 // ----------------------------------------------------------------------------
1964 // check/radio buttons
1965 // ----------------------------------------------------------------------------
1966
1967 wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
1968 {
1969 IndicatorState indState;
1970 if ( flags & wxCONTROL_SELECTED )
1971 indState = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
1972 : IndicatorState_Selected;
1973 else if ( flags & wxCONTROL_DISABLED )
1974 indState = IndicatorState_Disabled;
1975 else if ( flags & wxCONTROL_PRESSED )
1976 indState = IndicatorState_Pressed;
1977 else
1978 indState = IndicatorState_Normal;
1979
1980 IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
1981 ? IndicatorStatus_Checked
1982 : IndicatorStatus_Unchecked;
1983
1984 const char **xpm = bmpIndicators[indType][indState][indStatus];
1985 return xpm ? wxBitmap(xpm) : wxNullBitmap;
1986 }
1987
1988 void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
1989 const wxString& label,
1990 const wxBitmap& bitmap,
1991 const wxRect& rect,
1992 int flags,
1993 wxAlignment align,
1994 int indexAccel,
1995 wxCoord focusOffsetY)
1996 {
1997 // calculate the position of the bitmap and of the label
1998 wxCoord heightBmp = bitmap.GetHeight();
1999 wxCoord xBmp,
2000 yBmp = rect.y + (rect.height - heightBmp) / 2;
2001
2002 wxRect rectLabel;
2003 dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
2004 rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
2005
2006 // align label vertically with the bitmap - looks nicer like this
2007 rectLabel.y -= (rectLabel.height - heightBmp) % 2;
2008
2009 // calc horz position
2010 if ( align == wxALIGN_RIGHT )
2011 {
2012 xBmp = rect.GetRight() - bitmap.GetWidth();
2013 rectLabel.x = rect.x + 3;
2014 rectLabel.SetRight(xBmp);
2015 }
2016 else // normal (checkbox to the left of the text) case
2017 {
2018 xBmp = rect.x;
2019 rectLabel.x = xBmp + bitmap.GetWidth() + 5;
2020 rectLabel.SetRight(rect.GetRight());
2021 }
2022
2023 dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
2024
2025 DoDrawLabel(
2026 dc, label, rectLabel,
2027 flags,
2028 wxALIGN_LEFT | wxALIGN_TOP,
2029 indexAccel,
2030 NULL, // we don't need bounding rect
2031 // use custom vert focus rect offset
2032 wxPoint(FOCUS_RECT_OFFSET_X, focusOffsetY)
2033 );
2034 }
2035
2036 void wxWin32Renderer::DrawRadioButton(wxDC& dc,
2037 const wxString& label,
2038 const wxBitmap& bitmap,
2039 const wxRect& rect,
2040 int flags,
2041 wxAlignment align,
2042 int indexAccel)
2043 {
2044 DrawCheckOrRadioButton(dc, label,
2045 bitmap.Ok() ? bitmap : GetRadioBitmap(flags),
2046 rect, flags, align, indexAccel,
2047 FOCUS_RECT_OFFSET_Y); // default focus rect offset
2048 }
2049
2050 void wxWin32Renderer::DrawCheckButton(wxDC& dc,
2051 const wxString& label,
2052 const wxBitmap& bitmap,
2053 const wxRect& rect,
2054 int flags,
2055 wxAlignment align,
2056 int indexAccel)
2057 {
2058 DrawCheckOrRadioButton(dc, label,
2059 bitmap.Ok() ? bitmap : GetCheckBitmap(flags),
2060 rect, flags, align, indexAccel,
2061 0); // no focus rect offset for checkboxes
2062 }
2063
2064 // ----------------------------------------------------------------------------
2065 // text control
2066 // ----------------------------------------------------------------------------
2067
2068 void wxWin32Renderer::DrawTextLine(wxDC& dc,
2069 const wxString& text,
2070 const wxRect& rect,
2071 int selStart,
2072 int selEnd,
2073 int flags)
2074 {
2075 // nothing special to do here
2076 StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
2077 }
2078
2079 void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
2080 {
2081 // we don't draw them
2082 }
2083
2084 // ----------------------------------------------------------------------------
2085 // notebook
2086 // ----------------------------------------------------------------------------
2087
2088 void wxWin32Renderer::DrawTab(wxDC& dc,
2089 const wxRect& rectOrig,
2090 wxDirection dir,
2091 const wxString& label,
2092 const wxBitmap& bitmap,
2093 int flags,
2094 int indexAccel)
2095 {
2096 wxRect rect = rectOrig;
2097
2098 // the current tab is drawn indented (to the top for default case) and
2099 // bigger than the other ones
2100 const wxSize indent = GetTabIndent();
2101 if ( flags & wxCONTROL_SELECTED )
2102 {
2103 switch ( dir )
2104 {
2105 default:
2106 wxFAIL_MSG(_T("invaild notebook tab orientation"));
2107 // fall through
2108
2109 case wxTOP:
2110 rect.Inflate(indent.x, 0);
2111 rect.y -= indent.y;
2112 rect.height += indent.y;
2113 break;
2114
2115 case wxBOTTOM:
2116 rect.Inflate(indent.x, 0);
2117 rect.height += indent.y;
2118 break;
2119
2120 case wxLEFT:
2121 case wxRIGHT:
2122 wxFAIL_MSG(_T("TODO"));
2123 break;
2124 }
2125 }
2126
2127 // draw the text, image and the focus around them (if necessary)
2128 wxRect rectLabel = rect;
2129 rectLabel.Deflate(1, 1);
2130 DrawButtonLabel(dc, label, bitmap, rectLabel,
2131 flags, wxALIGN_CENTRE, indexAccel);
2132
2133 // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
2134 static const wxCoord CUTOFF = 2; // radius of the rounded corner
2135 wxCoord x = rect.x,
2136 y = rect.y,
2137 x2 = rect.GetRight(),
2138 y2 = rect.GetBottom();
2139
2140 // FIXME: all this code will break if the tab indent or the border width,
2141 // it is tied to the fact that both of them are equal to 2
2142 switch ( dir )
2143 {
2144 default:
2145 case wxTOP:
2146 dc.SetPen(m_penHighlight);
2147 dc.DrawLine(x, y2, x, y + CUTOFF);
2148 dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
2149 dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
2150
2151 dc.SetPen(m_penBlack);
2152 dc.DrawLine(x2, y2, x2, y + CUTOFF);
2153 dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
2154
2155 dc.SetPen(m_penDarkGrey);
2156 dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
2157
2158 if ( flags & wxCONTROL_SELECTED )
2159 {
2160 dc.SetPen(m_penLightGrey);
2161
2162 // overwrite the part of the border below this tab
2163 dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
2164
2165 // and the shadow of the tab to the left of us
2166 dc.DrawLine(x + 1, y + CUTOFF + 1, x + 1, y2 + 1);
2167 }
2168 break;
2169
2170 case wxBOTTOM:
2171 dc.SetPen(m_penHighlight);
2172 // we need to continue one pixel further to overwrite the corner of
2173 // the border for the selected tab
2174 dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
2175 x, y2 - CUTOFF);
2176 dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
2177
2178 dc.SetPen(m_penBlack);
2179 dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
2180 dc.DrawLine(x2, y, x2, y2 - CUTOFF);
2181 dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
2182
2183 dc.SetPen(m_penDarkGrey);
2184 dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
2185 dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
2186
2187 if ( flags & wxCONTROL_SELECTED )
2188 {
2189 dc.SetPen(m_penLightGrey);
2190
2191 // overwrite the part of the (double!) border above this tab
2192 dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
2193 dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
2194
2195 // and the shadow of the tab to the left of us
2196 dc.DrawLine(x + 1, y2 - CUTOFF, x + 1, y - 1);
2197 }
2198 break;
2199
2200 case wxLEFT:
2201 case wxRIGHT:
2202 wxFAIL_MSG(_T("TODO"));
2203 }
2204 }
2205
2206 // ----------------------------------------------------------------------------
2207 // slider
2208 // ----------------------------------------------------------------------------
2209
2210 wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
2211 wxOrientation orient) const
2212 {
2213 wxSize size;
2214
2215 wxRect rectShaft = GetSliderShaftRect(rect, orient);
2216 if ( orient == wxHORIZONTAL )
2217 {
2218 size.y = rect.height - 6;
2219 size.x = wxMin(size.y / 2, rectShaft.width);
2220 }
2221 else // vertical
2222 {
2223 size.x = rect.width - 6;
2224 size.y = wxMin(size.x / 2, rectShaft.height);
2225 }
2226
2227 return size;
2228 }
2229
2230 wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
2231 wxOrientation orient) const
2232 {
2233 static const wxCoord SLIDER_MARGIN = 6;
2234
2235 wxRect rect = rectOrig;
2236
2237 if ( orient == wxHORIZONTAL )
2238 {
2239 // make the rect of minimal width and centre it
2240 rect.height = 2*BORDER_THICKNESS;
2241 rect.y = rectOrig.y + (rectOrig.height - rect.height) / 2;
2242 if ( rect.y < 0 )
2243 rect.y = 0;
2244
2245 // leave margins on the sides
2246 rect.Deflate(SLIDER_MARGIN, 0);
2247 }
2248 else // vertical
2249 {
2250 // same as above but in other direction
2251 rect.width = 2*BORDER_THICKNESS;
2252 rect.x = rectOrig.x + (rectOrig.width - rect.width) / 2;
2253 if ( rect.x < 0 )
2254 rect.x = 0;
2255
2256 rect.Deflate(0, SLIDER_MARGIN);
2257 }
2258
2259 return rect;
2260 }
2261
2262 void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
2263 const wxRect& rectOrig,
2264 wxOrientation orient,
2265 int flags,
2266 wxRect *rectShaft)
2267 {
2268 if ( flags & wxCONTROL_FOCUSED )
2269 {
2270 DrawFocusRect(dc, rectOrig);
2271 }
2272
2273 wxRect rect = GetSliderShaftRect(rectOrig, orient);
2274
2275 if ( rectShaft )
2276 *rectShaft = rect;
2277
2278 DrawSunkenBorder(dc, &rect);
2279 }
2280
2281 void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
2282 const wxRect& rect,
2283 wxOrientation orient,
2284 int flags)
2285 {
2286 /*
2287 we are drawing a shape of this form
2288
2289 HHHHHHB <--- y
2290 H DB
2291 H DB
2292 H DB where H is hightlight colour
2293 H DB D dark grey
2294 H DB B black
2295 H DB
2296 H DB <--- y3
2297 H DB
2298 HDB
2299 B <--- y2
2300
2301 ^ ^ ^
2302 | | |
2303 x x3 x2
2304
2305 The interior of this shape is filled with the hatched brush if the thumb
2306 is pressed.
2307 */
2308
2309 DrawBackground(dc, wxNullColour, rect, flags);
2310
2311 bool transpose = orient == wxVERTICAL;
2312
2313 wxCoord x, y, x2, y2;
2314 if ( transpose )
2315 {
2316 x = rect.y;
2317 y = rect.x;
2318 x2 = rect.GetBottom();
2319 y2 = rect.GetRight();
2320 }
2321 else
2322 {
2323 x = rect.x;
2324 y = rect.y;
2325 x2 = rect.GetRight();
2326 y2 = rect.GetBottom();
2327 }
2328
2329 // the size of the pointed part of the thumb
2330 wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
2331
2332 wxCoord x3 = x + sizeArrow,
2333 y3 = y2 - sizeArrow;
2334
2335 dc.SetPen(m_penHighlight);
2336 DrawLine(dc, x, y, x2, y, transpose);
2337 DrawLine(dc, x, y + 1, x, y2 - sizeArrow, transpose);
2338 DrawLine(dc, x, y3, x3, y2, transpose);
2339
2340 dc.SetPen(m_penBlack);
2341 DrawLine(dc, x3, y2, x2, y3, transpose);
2342 DrawLine(dc, x2, y3, x2, y - 1, transpose);
2343
2344 dc.SetPen(m_penDarkGrey);
2345 DrawLine(dc, x3, y2 - 1, x2 - 1, y3, transpose);
2346 DrawLine(dc, x2 - 1, y3, x2 - 1, y, transpose);
2347
2348 if ( flags & wxCONTROL_PRESSED )
2349 {
2350 // TODO: MSW fills the entire area inside, not just the rect
2351 wxRect rectInt = rect;
2352 if ( transpose )
2353 rectInt.SetRight(y3);
2354 else
2355 rectInt.SetBottom(y3);
2356 rectInt.Deflate(2);
2357
2358 static const char *stipple_xpm[] = {
2359 /* columns rows colors chars-per-pixel */
2360 "2 2 2 1",
2361 " c None",
2362 "w c white",
2363 /* pixels */
2364 "w ",
2365 " w",
2366 };
2367 dc.SetBrush(wxBrush(stipple_xpm));
2368
2369 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
2370 dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));
2371 dc.SetPen(*wxTRANSPARENT_PEN);
2372 dc.DrawRectangle(rectInt);
2373 }
2374 }
2375
2376 void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
2377 const wxRect& rect,
2378 const wxSize& sizeThumb,
2379 wxOrientation orient,
2380 int start,
2381 int end,
2382 int step,
2383 int flags)
2384 {
2385 if ( end == start )
2386 {
2387 // empty slider?
2388 return;
2389 }
2390
2391 // the variable names correspond to horizontal case, but they can be used
2392 // for both orientations
2393 wxCoord x1, x2, y1, y2, len, widthThumb;
2394 if ( orient == wxHORIZONTAL )
2395 {
2396 x1 = rect.GetLeft();
2397 x2 = rect.GetRight();
2398
2399 // draw from bottom to top to leave one pixel space between the ticks
2400 // and the slider as Windows do
2401 y1 = rect.GetBottom();
2402 y2 = rect.GetTop();
2403
2404 len = rect.width;
2405
2406 widthThumb = sizeThumb.x;
2407 }
2408 else // vertical
2409 {
2410 x1 = rect.GetTop();
2411 x2 = rect.GetBottom();
2412
2413 y1 = rect.GetRight();
2414 y2 = rect.GetLeft();
2415
2416 len = rect.height;
2417
2418 widthThumb = sizeThumb.y;
2419 }
2420
2421 // the first tick should be positioned in such way that a thumb drawn in
2422 // the first position points down directly to it
2423 x1 += widthThumb / 2;
2424 x2 -= widthThumb / 2;
2425
2426 // this also means that we have slightly less space for the ticks in
2427 // between the first and the last
2428 len -= widthThumb;
2429
2430 dc.SetPen(m_penBlack);
2431
2432 int range = end - start;
2433 for ( int n = 0; n < range; n += step )
2434 {
2435 wxCoord x = x1 + (len*n) / range;
2436
2437 DrawLine(dc, x, y1, x, y2, orient == wxVERTICAL);
2438 }
2439
2440 // always draw the line at the end position
2441 DrawLine(dc, x2, y1, x2, y2, orient == wxVERTICAL);
2442 }
2443
2444 // ----------------------------------------------------------------------------
2445 // menu and menubar
2446 // ----------------------------------------------------------------------------
2447
2448 #if wxUSE_MENUS
2449
2450 // wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
2451 class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
2452 {
2453 public:
2454 virtual wxSize GetSize() const { return m_size; }
2455
2456 wxCoord GetLabelOffset() const { return m_ofsLabel; }
2457 wxCoord GetAccelOffset() const { return m_ofsAccel; }
2458
2459 wxCoord GetItemHeight() const { return m_heightItem; }
2460
2461 private:
2462 // the total size of the menu
2463 wxSize m_size;
2464
2465 // the offset of the start of the menu item label
2466 wxCoord m_ofsLabel;
2467
2468 // the offset of the start of the accel label
2469 wxCoord m_ofsAccel;
2470
2471 // the height of a normal (not separator) item
2472 wxCoord m_heightItem;
2473
2474 friend wxMenuGeometryInfo *wxWin32Renderer::
2475 GetMenuGeometry(wxWindow *, const wxMenu&) const;
2476 };
2477
2478 #endif // wxUSE_MENUS
2479
2480 // FIXME: all constants are hardcoded but shouldn't be
2481 static const wxCoord MENU_LEFT_MARGIN = 9;
2482 static const wxCoord MENU_RIGHT_MARGIN = 18;
2483 static const wxCoord MENU_VERT_MARGIN = 3;
2484
2485 // the margin around bitmap/check marks (on each side)
2486 static const wxCoord MENU_BMP_MARGIN = 2;
2487
2488 // the margin between the labels and accel strings
2489 static const wxCoord MENU_ACCEL_MARGIN = 8;
2490
2491 // the separator height in pixels: in fact, strangely enough, the real height
2492 // is 2 but Windows adds one extra pixel in the bottom margin, so take it into
2493 // account here
2494 static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
2495
2496 // the size of the standard checkmark bitmap
2497 static const wxCoord MENU_CHECK_SIZE = 9;
2498
2499 // we can't implement these methods without wxMenuGeometryInfo implementation
2500 // which we don't have if !wxUSE_MENUS
2501 #if wxUSE_MENUS
2502
2503 void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
2504 const wxRect& rectOrig,
2505 const wxString& label,
2506 int flags,
2507 int indexAccel)
2508 {
2509 wxRect rect = rectOrig;
2510 rect.height--;
2511
2512 wxDCTextColourChanger colChanger(dc);
2513
2514 if ( flags & wxCONTROL_SELECTED )
2515 {
2516 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2517
2518 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2519 dc.SetBrush(wxBrush(colBg, wxSOLID));
2520 dc.SetPen(wxPen(colBg, 0, wxSOLID));
2521 dc.DrawRectangle(rect);
2522 }
2523
2524 // don't draw the focus rect around menu bar items
2525 DrawLabel(dc, label, rect, flags & ~wxCONTROL_FOCUSED,
2526 wxALIGN_CENTRE, indexAccel);
2527 }
2528
2529 void wxWin32Renderer::DrawMenuItem(wxDC& dc,
2530 wxCoord y,
2531 const wxMenuGeometryInfo& gi,
2532 const wxString& label,
2533 const wxString& accel,
2534 const wxBitmap& bitmap,
2535 int flags,
2536 int indexAccel)
2537 {
2538 const wxWin32MenuGeometryInfo& geometryInfo =
2539 (const wxWin32MenuGeometryInfo&)gi;
2540
2541 wxRect rect;
2542 rect.x = 0;
2543 rect.y = y;
2544 rect.width = geometryInfo.GetSize().x;
2545 rect.height = geometryInfo.GetItemHeight();
2546
2547 // draw the selected item specially
2548 wxDCTextColourChanger colChanger(dc);
2549 if ( flags & wxCONTROL_SELECTED )
2550 {
2551 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2552
2553 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2554 dc.SetBrush(wxBrush(colBg, wxSOLID));
2555 dc.SetPen(wxPen(colBg, 0, wxSOLID));
2556 dc.DrawRectangle(rect);
2557 }
2558
2559 // draw the bitmap: use the bitmap provided or the standard checkmark for
2560 // the checkable items
2561 wxBitmap bmp = bitmap;
2562 if ( !bmp.Ok() && (flags & wxCONTROL_CHECKED) )
2563 {
2564 bmp = GetIndicator(IndicatorType_Menu, flags);
2565 }
2566
2567 if ( bmp.Ok() )
2568 {
2569 rect.SetRight(geometryInfo.GetLabelOffset());
2570 wxControlRenderer::DrawBitmap(dc, bmp, rect);
2571 }
2572
2573 // draw the label
2574 rect.x = geometryInfo.GetLabelOffset();
2575 rect.SetRight(geometryInfo.GetAccelOffset());
2576
2577 DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE_VERTICAL, indexAccel);
2578
2579 // draw the accel string
2580 rect.x = geometryInfo.GetAccelOffset();
2581 rect.SetRight(geometryInfo.GetSize().x);
2582
2583 // NB: no accel index here
2584 DrawLabel(dc, accel, rect, flags, wxALIGN_CENTRE_VERTICAL);
2585
2586 // draw the submenu indicator
2587 if ( flags & wxCONTROL_ISSUBMENU )
2588 {
2589 rect.x = geometryInfo.GetSize().x - MENU_RIGHT_MARGIN;
2590 rect.width = MENU_RIGHT_MARGIN;
2591
2592 wxArrowStyle arrowStyle;
2593 if ( flags & wxCONTROL_DISABLED )
2594 arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
2595 : Arrow_Disabled;
2596 else if ( flags & wxCONTROL_SELECTED )
2597 arrowStyle = Arrow_Inversed;
2598 else
2599 arrowStyle = Arrow_Normal;
2600
2601 DrawArrow(dc, rect, Arrow_Right, arrowStyle);
2602 }
2603 }
2604
2605 void wxWin32Renderer::DrawMenuSeparator(wxDC& dc,
2606 wxCoord y,
2607 const wxMenuGeometryInfo& geomInfo)
2608 {
2609 DrawHorizontalLine(dc, y + MENU_VERT_MARGIN, 0, geomInfo.GetSize().x);
2610 }
2611
2612 wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& sizeText) const
2613 {
2614 wxSize size = sizeText;
2615
2616 // FIXME: menubar height is configurable under Windows
2617 size.x += 12;
2618 size.y += 6;
2619
2620 return size;
2621 }
2622
2623 wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
2624 const wxMenu& menu) const
2625 {
2626 // prepare the dc: for now we draw all the items with the system font
2627 wxClientDC dc(win);
2628 dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
2629
2630 // the height of a normal item
2631 wxCoord heightText = dc.GetCharHeight();
2632
2633 // the total height
2634 wxCoord height = 0;
2635
2636 // the max length of label and accel strings: the menu width is the sum of
2637 // them, even if they're for different items (as the accels should be
2638 // aligned)
2639 //
2640 // the max length of the bitmap is never 0 as Windows always leaves enough
2641 // space for a check mark indicator
2642 wxCoord widthLabelMax = 0,
2643 widthAccelMax = 0,
2644 widthBmpMax = MENU_LEFT_MARGIN;
2645
2646 for ( wxMenuItemList::Node *node = menu.GetMenuItems().GetFirst();
2647 node;
2648 node = node->GetNext() )
2649 {
2650 // height of this item
2651 wxCoord h;
2652
2653 wxMenuItem *item = node->GetData();
2654 if ( item->IsSeparator() )
2655 {
2656 h = MENU_SEPARATOR_HEIGHT;
2657 }
2658 else // not separator
2659 {
2660 h = heightText;
2661
2662 wxCoord widthLabel;
2663 dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
2664 if ( widthLabel > widthLabelMax )
2665 {
2666 widthLabelMax = widthLabel;
2667 }
2668
2669 wxCoord widthAccel;
2670 dc.GetTextExtent(item->GetAccelString(), &widthAccel, NULL);
2671 if ( widthAccel > widthAccelMax )
2672 {
2673 widthAccelMax = widthAccel;
2674 }
2675
2676 const wxBitmap& bmp = item->GetBitmap();
2677 if ( bmp.Ok() )
2678 {
2679 wxCoord widthBmp = bmp.GetWidth();
2680 if ( widthBmp > widthBmpMax )
2681 widthBmpMax = widthBmp;
2682 }
2683 //else if ( item->IsCheckable() ): no need to check for this as
2684 // MENU_LEFT_MARGIN is big enough to show the check mark
2685 }
2686
2687 h += 2*MENU_VERT_MARGIN;
2688
2689 // remember the item position and height
2690 item->SetGeometry(height, h);
2691
2692 height += h;
2693 }
2694
2695 // bundle the metrics into a struct and return it
2696 wxWin32MenuGeometryInfo *gi = new wxWin32MenuGeometryInfo;
2697
2698 gi->m_ofsLabel = widthBmpMax + 2*MENU_BMP_MARGIN;
2699 gi->m_ofsAccel = gi->m_ofsLabel + widthLabelMax;
2700 if ( widthAccelMax > 0 )
2701 {
2702 // if we actually have any accesl, add a margin
2703 gi->m_ofsAccel += MENU_ACCEL_MARGIN;
2704 }
2705
2706 gi->m_heightItem = heightText + 2*MENU_VERT_MARGIN;
2707
2708 gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
2709 gi->m_size.y = height;
2710
2711 return gi;
2712 }
2713
2714 #else // !wxUSE_MENUS
2715
2716 /*
2717 void wxWin32Renderer::DrawMenuBarItem(wxDC& WXUNUSED(dc),
2718 const wxRect& WXUNUSED(rectOrig),
2719 const wxString& WXUNUSED(label),
2720 int WXUNUSED(flags),
2721 int WXUNUSED(indexAccel))
2722 {
2723 }
2724
2725 void wxWin32Renderer::DrawMenuItem(wxDC& WXUNUSED(dc),
2726 wxCoord WXUNUSED(y),
2727 const wxMenuGeometryInfo& WXUNUSED(gi),
2728 const wxString& WXUNUSED(label),
2729 const wxString& WXUNUSED(accel),
2730 const wxBitmap& WXUNUSED(bitmap),
2731 int WXUNUSED(flags),
2732 int WXUNUSED(indexAccel))
2733 {
2734 }
2735
2736 void wxWin32Renderer::DrawMenuSeparator(wxDC& WXUNUSED(dc),
2737 wxCoord WXUNUSED(y),
2738 const wxMenuGeometryInfo& WXUNUSED(gi))
2739 {
2740 }
2741
2742 wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& size) const
2743 {
2744 return size;
2745 }
2746
2747 wxMenuGeometryInfo *
2748 wxWin32Renderer::GetMenuGeometry(wxWindow *WXUNUSED(win),
2749 const wxMenu& WXUNUSED(menu)) const
2750 {
2751 return NULL;
2752 }
2753 */
2754
2755 #endif // wxUSE_MENUS/!wxUSE_MENUS
2756
2757 // ----------------------------------------------------------------------------
2758 // combobox
2759 // ----------------------------------------------------------------------------
2760
2761 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
2762 wxBitmap *bmpPressed,
2763 wxBitmap *bmpDisabled)
2764 {
2765 static const wxCoord widthCombo = 16;
2766 static const wxCoord heightCombo = 17;
2767
2768 wxMemoryDC dcMem;
2769
2770 if ( bmpNormal )
2771 {
2772 bmpNormal->Create(widthCombo, heightCombo);
2773 dcMem.SelectObject(*bmpNormal);
2774 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
2775 Arrow_Down, Arrow_Normal);
2776 }
2777
2778 if ( bmpPressed )
2779 {
2780 bmpPressed->Create(widthCombo, heightCombo);
2781 dcMem.SelectObject(*bmpPressed);
2782 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
2783 Arrow_Down, Arrow_Pressed);
2784 }
2785
2786 if ( bmpDisabled )
2787 {
2788 bmpDisabled->Create(widthCombo, heightCombo);
2789 dcMem.SelectObject(*bmpDisabled);
2790 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
2791 Arrow_Down, Arrow_Disabled);
2792 }
2793 }
2794
2795 // ----------------------------------------------------------------------------
2796 // background
2797 // ----------------------------------------------------------------------------
2798
2799 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
2800 const wxColour& col,
2801 const wxRect& rect)
2802 {
2803 wxBrush brush(col, wxSOLID);
2804 dc.SetBrush(brush);
2805 dc.SetPen(*wxTRANSPARENT_PEN);
2806 dc.DrawRectangle(rect);
2807 }
2808
2809 void wxWin32Renderer::DrawBackground(wxDC& dc,
2810 const wxColour& col,
2811 const wxRect& rect,
2812 int flags)
2813 {
2814 // just fill it with the given or default bg colour
2815 wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
2816 DoDrawBackground(dc, colBg, rect);
2817 }
2818
2819 // ----------------------------------------------------------------------------
2820 // scrollbar
2821 // ----------------------------------------------------------------------------
2822
2823 void wxWin32Renderer::DrawArrow(wxDC& dc,
2824 wxDirection dir,
2825 const wxRect& rect,
2826 int flags)
2827 {
2828 // get the bitmap for this arrow
2829 wxArrowDirection arrowDir;
2830 switch ( dir )
2831 {
2832 case wxLEFT: arrowDir = Arrow_Left; break;
2833 case wxRIGHT: arrowDir = Arrow_Right; break;
2834 case wxUP: arrowDir = Arrow_Up; break;
2835 case wxDOWN: arrowDir = Arrow_Down; break;
2836
2837 default:
2838 wxFAIL_MSG(_T("unknown arrow direction"));
2839 return;
2840 }
2841
2842 wxArrowStyle arrowStyle;
2843 if ( flags & wxCONTROL_PRESSED )
2844 {
2845 // can't be pressed and disabled
2846 arrowStyle = Arrow_Pressed;
2847 }
2848 else
2849 {
2850 arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
2851 }
2852
2853 DrawArrowButton(dc, rect, arrowDir, arrowStyle);
2854 }
2855
2856 void wxWin32Renderer::DrawArrow(wxDC& dc,
2857 const wxRect& rect,
2858 wxArrowDirection arrowDir,
2859 wxArrowStyle arrowStyle)
2860 {
2861 const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
2862
2863 // under Windows the arrows always have the same size so just centre it in
2864 // the provided rectangle
2865 wxCoord x = rect.x + (rect.width - bmp.GetWidth()) / 2,
2866 y = rect.y + (rect.height - bmp.GetHeight()) / 2;
2867
2868 // Windows does it like this...
2869 if ( arrowDir == Arrow_Left )
2870 x--;
2871
2872 // draw it
2873 dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
2874 }
2875
2876 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
2877 const wxRect& rectAll,
2878 wxArrowDirection arrowDir,
2879 wxArrowStyle arrowStyle)
2880 {
2881 wxRect rect = rectAll;
2882 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
2883 DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
2884 DrawArrow(dc, rect, arrowDir, arrowStyle);
2885 }
2886
2887 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
2888 wxOrientation orient,
2889 const wxRect& rect,
2890 int flags)
2891 {
2892 // we don't use the flags, the thumb never changes appearance
2893 wxRect rectThumb = rect;
2894 DrawArrowBorder(dc, &rectThumb);
2895 DrawBackground(dc, wxNullColour, rectThumb);
2896 }
2897
2898 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
2899 wxOrientation orient,
2900 const wxRect& rectBar,
2901 int flags)
2902 {
2903 wxColourScheme::StdColour col = flags & wxCONTROL_PRESSED
2904 ? wxColourScheme::SCROLLBAR_PRESSED
2905 : wxColourScheme::SCROLLBAR;
2906 DoDrawBackground(dc, m_scheme->Get(col), rectBar);
2907 }
2908
2909 void wxWin32Renderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
2910 {
2911 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
2912 }
2913
2914 wxRect wxWin32Renderer::GetScrollbarRect(const wxScrollBar *scrollbar,
2915 wxScrollBar::Element elem,
2916 int thumbPos) const
2917 {
2918 return StandardGetScrollbarRect(scrollbar, elem,
2919 thumbPos, m_sizeScrollbarArrow);
2920 }
2921
2922 wxCoord wxWin32Renderer::GetScrollbarSize(const wxScrollBar *scrollbar)
2923 {
2924 return StandardScrollBarSize(scrollbar, m_sizeScrollbarArrow);
2925 }
2926
2927 wxHitTest wxWin32Renderer::HitTestScrollbar(const wxScrollBar *scrollbar,
2928 const wxPoint& pt) const
2929 {
2930 return StandardHitTestScrollbar(scrollbar, pt, m_sizeScrollbarArrow);
2931 }
2932
2933 wxCoord wxWin32Renderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
2934 int thumbPos)
2935 {
2936 return StandardScrollbarToPixel(scrollbar, thumbPos, m_sizeScrollbarArrow);
2937 }
2938
2939 int wxWin32Renderer::PixelToScrollbar(const wxScrollBar *scrollbar,
2940 wxCoord coord)
2941 {
2942 return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
2943 }
2944
2945 // ----------------------------------------------------------------------------
2946 // text control geometry
2947 // ----------------------------------------------------------------------------
2948
2949 static inline int GetTextBorderWidth()
2950 {
2951 return 1;
2952 }
2953
2954 wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
2955 const wxRect& rect)
2956 {
2957 wxRect rectTotal = rect;
2958
2959 wxCoord widthBorder = GetTextBorderWidth();
2960 rectTotal.Inflate(widthBorder);
2961
2962 // this is what Windows does
2963 rectTotal.height++;
2964
2965 return rectTotal;
2966 }
2967
2968 wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
2969 const wxRect& rect,
2970 wxCoord *extraSpaceBeyond)
2971 {
2972 wxRect rectText = rect;
2973
2974 // undo GetTextTotalArea()
2975 if ( rectText.height > 0 )
2976 rectText.height--;
2977
2978 wxCoord widthBorder = GetTextBorderWidth();
2979 rectText.Inflate(-widthBorder);
2980
2981 if ( extraSpaceBeyond )
2982 *extraSpaceBeyond = 0;
2983
2984 return rectText;
2985 }
2986
2987 // ----------------------------------------------------------------------------
2988 // size adjustments
2989 // ----------------------------------------------------------------------------
2990
2991 void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
2992 {
2993 #if wxUSE_SCROLLBAR
2994 if ( wxDynamicCast(window, wxScrollBar) )
2995 {
2996 // we only set the width of vert scrollbars and height of the
2997 // horizontal ones
2998 if ( window->GetWindowStyle() & wxSB_HORIZONTAL )
2999 size->y = m_sizeScrollbarArrow.y;
3000 else
3001 size->x = m_sizeScrollbarArrow.x;
3002
3003 // skip border width adjustments, they don't make sense for us
3004 return;
3005 }
3006 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
3007
3008 #if wxUSE_BUTTON
3009 if ( wxDynamicCast(window, wxButton) )
3010 {
3011 // TODO
3012 size->x += 3*window->GetCharWidth();
3013 #if 0 // do allow creating small buttons if wanted
3014 wxSize sizeDef = wxButton::GetDefaultSize();
3015 if ( size->x < sizeDef.x )
3016 size->x = sizeDef.x;
3017 #endif // 0
3018
3019 wxCoord heightBtn = (11*(window->GetCharHeight() + 8))/10;
3020 if ( size->y < heightBtn - 8 )
3021 size->y = heightBtn;
3022 else
3023 size->y += 9;
3024
3025 // no border width adjustments for buttons
3026 return;
3027 }
3028 #endif // wxUSE_BUTTON
3029
3030 // take into account the border width
3031 wxRect rectBorder = GetBorderDimensions(window->GetBorder());
3032 size->x += rectBorder.x + rectBorder.width;
3033 size->y += rectBorder.y + rectBorder.height;
3034 }
3035
3036 // ============================================================================
3037 // wxInputHandler
3038 // ============================================================================
3039
3040 // ----------------------------------------------------------------------------
3041 // wxWin32InputHandler
3042 // ----------------------------------------------------------------------------
3043
3044 wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
3045 {
3046 m_renderer = renderer;
3047 }
3048
3049 bool wxWin32InputHandler::HandleKey(wxControl *control,
3050 const wxKeyEvent& event,
3051 bool pressed)
3052 {
3053 return FALSE;
3054 }
3055
3056 bool wxWin32InputHandler::HandleMouse(wxControl *control,
3057 const wxMouseEvent& event)
3058 {
3059 return FALSE;
3060 }
3061
3062 // ----------------------------------------------------------------------------
3063 // wxWin32ScrollBarInputHandler
3064 // ----------------------------------------------------------------------------
3065
3066 wxWin32ScrollBarInputHandler::
3067 wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
3068 wxInputHandler *handler)
3069 : wxStdScrollBarInputHandler(renderer, handler)
3070 {
3071 m_scrollPaused = FALSE;
3072 m_interval = 0;
3073 }
3074
3075 bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
3076 const wxControlAction& action)
3077 {
3078 // stop if went beyond the position of the original click (this can only
3079 // happen when we scroll by pages)
3080 bool stop = FALSE;
3081 if ( action == wxACTION_SCROLL_PAGE_DOWN )
3082 {
3083 stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
3084 != wxHT_SCROLLBAR_BAR_2;
3085 }
3086 else if ( action == wxACTION_SCROLL_PAGE_UP )
3087 {
3088 stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
3089 != wxHT_SCROLLBAR_BAR_1;
3090 }
3091
3092 if ( stop )
3093 {
3094 StopScrolling(scrollbar);
3095
3096 scrollbar->Refresh();
3097
3098 return FALSE;
3099 }
3100
3101 return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
3102 }
3103
3104 bool wxWin32ScrollBarInputHandler::HandleMouse(wxControl *control,
3105 const wxMouseEvent& event)
3106 {
3107 // remember the current state
3108 bool wasDraggingThumb = m_htLast == wxHT_SCROLLBAR_THUMB;
3109
3110 // do process the message
3111 bool rc = wxStdScrollBarInputHandler::HandleMouse(control, event);
3112
3113 // analyse the changes
3114 if ( !wasDraggingThumb && (m_htLast == wxHT_SCROLLBAR_THUMB) )
3115 {
3116 // we just started dragging the thumb, remember its initial position to
3117 // be able to restore it if the drag is cancelled later
3118 m_eventStartDrag = event;
3119 }
3120
3121 return rc;
3122 }
3123
3124 bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxControl *control,
3125 const wxMouseEvent& event)
3126 {
3127 // we don't highlight scrollbar elements, so there is no need to process
3128 // mouse move events normally - only do it while mouse is captured (i.e.
3129 // when we're dragging the thumb or pressing on something)
3130 if ( !m_winCapture )
3131 return FALSE;
3132
3133 if ( event.Entering() )
3134 {
3135 // we're not interested in this at all
3136 return FALSE;
3137 }
3138
3139 wxScrollBar *scrollbar = wxStaticCast(control, wxScrollBar);
3140 wxHitTest ht;
3141 if ( m_scrollPaused )
3142 {
3143 // check if the mouse returned to its original location
3144
3145 if ( event.Leaving() )
3146 {
3147 // it surely didn't
3148 return FALSE;
3149 }
3150
3151 ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
3152 if ( ht == m_htLast )
3153 {
3154 // yes it did, resume scrolling
3155 m_scrollPaused = FALSE;
3156 if ( m_timerScroll )
3157 {
3158 // we were scrolling by line/page, restart timer
3159 m_timerScroll->Start(m_interval);
3160
3161 Press(scrollbar, TRUE);
3162 }
3163 else // we were dragging the thumb
3164 {
3165 // restore its last location
3166 HandleThumbMove(scrollbar, m_eventLastDrag);
3167 }
3168
3169 return TRUE;
3170 }
3171 }
3172 else // normal case, scrolling hasn't been paused
3173 {
3174 // if we're scrolling the scrollbar because the arrow or the shaft was
3175 // pressed, check that the mouse stays on the same scrollbar element
3176
3177 if ( event.Moving() )
3178 {
3179 ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
3180 }
3181 else // event.Leaving()
3182 {
3183 ht = wxHT_NOWHERE;
3184 }
3185
3186 // if we're dragging the thumb and the mouse stays in the scrollbar, it
3187 // is still ok - we only want to catch the case when the mouse leaves
3188 // the scrollbar here
3189 if ( m_htLast == wxHT_SCROLLBAR_THUMB && ht != wxHT_NOWHERE )
3190 {
3191 ht = wxHT_SCROLLBAR_THUMB;
3192 }
3193
3194 if ( ht != m_htLast )
3195 {
3196 // what were we doing? 2 possibilities: either an arrow/shaft was
3197 // pressed in which case we have a timer and so we just stop it or
3198 // we were dragging the thumb
3199 if ( m_timerScroll )
3200 {
3201 // pause scrolling
3202 m_interval = m_timerScroll->GetInterval();
3203 m_timerScroll->Stop();
3204 m_scrollPaused = TRUE;
3205
3206 // unpress the arrow
3207 Press(scrollbar, FALSE);
3208 }
3209 else // we were dragging the thumb
3210 {
3211 // remember the current thumb position to be able to restore it
3212 // if the mouse returns to it later
3213 m_eventLastDrag = event;
3214
3215 // and restore the original position (before dragging) of the
3216 // thumb for now
3217 HandleThumbMove(scrollbar, m_eventStartDrag);
3218 }
3219
3220 return TRUE;
3221 }
3222 }
3223
3224 return wxStdScrollBarInputHandler::HandleMouseMove(control, event);
3225 }
3226
3227 // ----------------------------------------------------------------------------
3228 // wxWin32CheckboxInputHandler
3229 // ----------------------------------------------------------------------------
3230
3231 bool wxWin32CheckboxInputHandler::HandleKey(wxControl *control,
3232 const wxKeyEvent& event,
3233 bool pressed)
3234 {
3235 if ( pressed )
3236 {
3237 wxControlAction action;
3238 int keycode = event.GetKeyCode();
3239 switch ( keycode )
3240 {
3241 case WXK_SPACE:
3242 action = wxACTION_CHECKBOX_TOGGLE;
3243 break;
3244
3245 case WXK_SUBTRACT:
3246 case WXK_NUMPAD_SUBTRACT:
3247 action = wxACTION_CHECKBOX_CHECK;
3248 break;
3249
3250 case WXK_ADD:
3251 case WXK_NUMPAD_ADD:
3252 case WXK_NUMPAD_EQUAL:
3253 action = wxACTION_CHECKBOX_CLEAR;
3254 break;
3255 }
3256
3257 if ( !!action )
3258 {
3259 control->PerformAction(action);
3260
3261 return TRUE;
3262 }
3263 }
3264
3265 return FALSE;
3266 }
3267
3268 // ----------------------------------------------------------------------------
3269 // wxWin32TextCtrlInputHandler
3270 // ----------------------------------------------------------------------------
3271
3272 bool wxWin32TextCtrlInputHandler::HandleKey(wxControl *control,
3273 const wxKeyEvent& event,
3274 bool pressed)
3275 {
3276 // handle only MSW-specific text bindings here, the others are handled in
3277 // the base class
3278 if ( pressed )
3279 {
3280 int keycode = event.GetKeyCode();
3281
3282 wxControlAction action;
3283 if ( keycode == WXK_DELETE && event.ShiftDown() )
3284 {
3285 action = wxACTION_TEXT_CUT;
3286 }
3287 else if ( keycode == WXK_INSERT )
3288 {
3289 if ( event.ControlDown() )
3290 action = wxACTION_TEXT_COPY;
3291 else if ( event.ShiftDown() )
3292 action = wxACTION_TEXT_PASTE;
3293 }
3294
3295 if ( action != wxACTION_NONE )
3296 {
3297 control->PerformAction(action);
3298
3299 return TRUE;
3300 }
3301 }
3302
3303 return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
3304 }
3305
wxWidgets (Impactor)