]> 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
use better check for drives even with Mingw32 (and, later, MSDOS)
[wxWidgets.git] / src / univ / themes / win32.cpp
1 // Name: univ/themes/win32.cpp
2 // Purpose: wxUniversal theme implementing Win32-like LNF
3 // Author: Vadim Zeitlin
4 // Modified by:
5 // Created: 06.08.00
6 // RCS-ID: $Id$
7 // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
8 // Licence: wxWindows license
9 ///////////////////////////////////////////////////////////////////////////////
10
11 // ===========================================================================
12 // declarations
13 // ===========================================================================
14
15 // ---------------------------------------------------------------------------
16 // headers
17 // ---------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #ifndef WX_PRECOMP
27 #include "wx/timer.h"
28 #include "wx/intl.h"
29 #include "wx/dc.h"
30 #include "wx/window.h"
31
32 #include "wx/dcmemory.h"
33
34 #include "wx/button.h"
35 #include "wx/listbox.h"
36 #include "wx/checklst.h"
37 #include "wx/combobox.h"
38 #include "wx/scrolbar.h"
39 #include "wx/slider.h"
40 #include "wx/textctrl.h"
41
42 #ifdef __WXMSW__
43 // for COLOR_* constants
44 #include "wx/msw/private.h"
45 #endif
46 #endif // WX_PRECOMP
47
48 #include "wx/notebook.h"
49 #include "wx/spinbutt.h"
50 #include "wx/settings.h"
51 #include "wx/menu.h"
52
53 #include "wx/univ/scrtimer.h"
54 #include "wx/toplevel.h"
55 #include "wx/univ/renderer.h"
56 #include "wx/univ/inphand.h"
57 #include "wx/univ/colschem.h"
58 #include "wx/univ/theme.h"
59
60 // ----------------------------------------------------------------------------
61 // constants
62 // ----------------------------------------------------------------------------
63
64 static const int BORDER_THICKNESS = 2;
65
66 // the offset between the label and focus rect around it
67 static const int FOCUS_RECT_OFFSET_X = 1;
68 static const int FOCUS_RECT_OFFSET_Y = 1;
69
70 static const int FRAME_BORDER_THICKNESS = 3;
71 static const int RESIZEABLE_FRAME_BORDER_THICKNESS = 4;
72 static const int FRAME_TITLEBAR_HEIGHT = 18;
73 static const int FRAME_BUTTON_WIDTH = 16;
74 static const int FRAME_BUTTON_HEIGHT = 14;
75
76 static const size_t NUM_STATUSBAR_GRIP_BANDS = 3;
77 static const size_t WIDTH_STATUSBAR_GRIP_BAND = 4;
78 static const size_t STATUSBAR_GRIP_SIZE =
79 WIDTH_STATUSBAR_GRIP_BAND*NUM_STATUSBAR_GRIP_BANDS;
80
81 enum IndicatorType
82 {
83 IndicatorType_Check,
84 IndicatorType_Radio,
85 IndicatorType_Menu,
86 IndicatorType_Max
87 };
88
89 enum IndicatorState
90 {
91 IndicatorState_Normal,
92 IndicatorState_Pressed, // this one is for check/radioboxes
93 IndicatorState_Selected = IndicatorState_Pressed, // for menus
94 IndicatorState_Disabled,
95 IndicatorState_SelectedDisabled, // only for the menus
96 IndicatorState_Max
97 };
98
99 enum IndicatorStatus
100 {
101 IndicatorStatus_Checked,
102 IndicatorStatus_Unchecked,
103 IndicatorStatus_Max
104 };
105
106 // wxWin32Renderer: draw the GUI elements in Win32 style
107 // ----------------------------------------------------------------------------
108
109 class wxWin32Renderer : public wxRenderer
110 {
111 public:
112 // constants
113 enum wxArrowDirection
114 {
115 Arrow_Left,
116 Arrow_Right,
117 Arrow_Up,
118 Arrow_Down,
119 Arrow_Max
120 };
121
122 enum wxArrowStyle
123 {
124 Arrow_Normal,
125 Arrow_Disabled,
126 Arrow_Pressed,
127 Arrow_Inversed,
128 Arrow_InversedDisabled,
129 Arrow_StateMax
130 };
131
132 enum wxFrameButtonType
133 {
134 FrameButton_Close,
135 FrameButton_Minimize,
136 FrameButton_Maximize,
137 FrameButton_Restore,
138 FrameButton_Help,
139 FrameButton_Max
140 };
141
142 // ctor
143 wxWin32Renderer(const wxColourScheme *scheme);
144
145 // implement the base class pure virtuals
146 virtual void DrawBackground(wxDC& dc,
147 const wxColour& col,
148 const wxRect& rect,
149 int flags = 0);
150 virtual void DrawLabel(wxDC& dc,
151 const wxString& label,
152 const wxRect& rect,
153 int flags = 0,
154 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
155 int indexAccel = -1,
156 wxRect *rectBounds = NULL);
157 virtual void DrawButtonLabel(wxDC& dc,
158 const wxString& label,
159 const wxBitmap& image,
160 const wxRect& rect,
161 int flags = 0,
162 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
163 int indexAccel = -1,
164 wxRect *rectBounds = NULL);
165 virtual void DrawBorder(wxDC& dc,
166 wxBorder border,
167 const wxRect& rect,
168 int flags = 0,
169 wxRect *rectIn = (wxRect *)NULL);
170 virtual void DrawHorizontalLine(wxDC& dc,
171 wxCoord y, wxCoord x1, wxCoord x2);
172 virtual void DrawVerticalLine(wxDC& dc,
173 wxCoord x, wxCoord y1, wxCoord y2);
174 virtual void DrawFrame(wxDC& dc,
175 const wxString& label,
176 const wxRect& rect,
177 int flags = 0,
178 int alignment = wxALIGN_LEFT,
179 int indexAccel = -1);
180 virtual void DrawTextBorder(wxDC& dc,
181 wxBorder border,
182 const wxRect& rect,
183 int flags = 0,
184 wxRect *rectIn = (wxRect *)NULL);
185 virtual void DrawButtonBorder(wxDC& dc,
186 const wxRect& rect,
187 int flags = 0,
188 wxRect *rectIn = (wxRect *)NULL);
189 virtual void DrawArrow(wxDC& dc,
190 wxDirection dir,
191 const wxRect& rect,
192 int flags = 0);
193 virtual void DrawScrollbarArrow(wxDC& dc,
194 wxDirection dir,
195 const wxRect& rect,
196 int flags = 0)
197 { DrawArrow(dc, dir, rect, flags); }
198 virtual void DrawScrollbarThumb(wxDC& dc,
199 wxOrientation orient,
200 const wxRect& rect,
201 int flags = 0);
202 virtual void DrawScrollbarShaft(wxDC& dc,
203 wxOrientation orient,
204 const wxRect& rect,
205 int flags = 0);
206 virtual void DrawScrollCorner(wxDC& dc,
207 const wxRect& rect);
208 virtual void DrawItem(wxDC& dc,
209 const wxString& label,
210 const wxRect& rect,
211 int flags = 0);
212 virtual void DrawCheckItem(wxDC& dc,
213 const wxString& label,
214 const wxBitmap& bitmap,
215 const wxRect& rect,
216 int flags = 0);
217 virtual void DrawCheckButton(wxDC& dc,
218 const wxString& label,
219 const wxBitmap& bitmap,
220 const wxRect& rect,
221 int flags = 0,
222 wxAlignment align = wxALIGN_LEFT,
223 int indexAccel = -1);
224 virtual void DrawRadioButton(wxDC& dc,
225 const wxString& label,
226 const wxBitmap& bitmap,
227 const wxRect& rect,
228 int flags = 0,
229 wxAlignment align = wxALIGN_LEFT,
230 int indexAccel = -1);
231 virtual void DrawTextLine(wxDC& dc,
232 const wxString& text,
233 const wxRect& rect,
234 int selStart = -1,
235 int selEnd = -1,
236 int flags = 0);
237 virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect);
238 virtual void DrawTab(wxDC& dc,
239 const wxRect& rect,
240 wxDirection dir,
241 const wxString& label,
242 const wxBitmap& bitmap = wxNullBitmap,
243 int flags = 0,
244 int indexAccel = -1);
245
246 virtual void DrawSliderShaft(wxDC& dc,
247 const wxRect& rect,
248 wxOrientation orient,
249 int flags = 0,
250 wxRect *rectShaft = NULL);
251 virtual void DrawSliderThumb(wxDC& dc,
252 const wxRect& rect,
253 wxOrientation orient,
254 int flags = 0);
255 virtual void DrawSliderTicks(wxDC& dc,
256 const wxRect& rect,
257 const wxSize& sizeThumb,
258 wxOrientation orient,
259 int start,
260 int end,
261 int step = 1,
262 int flags = 0);
263
264 virtual void DrawMenuBarItem(wxDC& dc,
265 const wxRect& rect,
266 const wxString& label,
267 int flags = 0,
268 int indexAccel = -1);
269 virtual void DrawMenuItem(wxDC& dc,
270 wxCoord y,
271 const wxMenuGeometryInfo& geometryInfo,
272 const wxString& label,
273 const wxString& accel,
274 const wxBitmap& bitmap = wxNullBitmap,
275 int flags = 0,
276 int indexAccel = -1);
277 virtual void DrawMenuSeparator(wxDC& dc,
278 wxCoord y,
279 const wxMenuGeometryInfo& geomInfo);
280
281 virtual void DrawStatusField(wxDC& dc,
282 const wxRect& rect,
283 const wxString& label,
284 int flags = 0);
285
286 // titlebars
287 virtual void DrawFrameTitleBar(wxDC& dc,
288 const wxRect& rect,
289 const wxString& title,
290 const wxIcon& icon,
291 int flags,
292 int specialButton = 0,
293 int specialButtonFlags = 0);
294 virtual void DrawFrameBorder(wxDC& dc,
295 const wxRect& rect,
296 int flags);
297 virtual void DrawFrameBackground(wxDC& dc,
298 const wxRect& rect,
299 int flags);
300 virtual void DrawFrameTitle(wxDC& dc,
301 const wxRect& rect,
302 const wxString& title,
303 int flags);
304 virtual void DrawFrameIcon(wxDC& dc,
305 const wxRect& rect,
306 const wxIcon& icon,
307 int flags);
308 virtual void DrawFrameButton(wxDC& dc,
309 wxCoord x, wxCoord y,
310 int button,
311 int flags = 0);
312 virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const;
313 virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const;
314 virtual wxSize GetFrameIconSize() const;
315 virtual int HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const;
316
317 virtual wxIcon GetStdIcon(int which) const;
318
319 virtual void GetComboBitmaps(wxBitmap *bmpNormal,
320 wxBitmap *bmpFocus,
321 wxBitmap *bmpPressed,
322 wxBitmap *bmpDisabled);
323
324 virtual void AdjustSize(wxSize *size, const wxWindow *window);
325 virtual wxRect GetBorderDimensions(wxBorder border) const;
326 virtual bool AreScrollbarsInsideBorder() const;
327
328 virtual wxSize GetScrollbarArrowSize() const
329 { return m_sizeScrollbarArrow; }
330 virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
331 wxScrollBar::Element elem,
332 int thumbPos = -1) const;
333 virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar);
334 virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
335 const wxPoint& pt) const;
336 virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
337 int thumbPos = -1);
338 virtual int PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord);
339 virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
340 { return fontHeight + 2; }
341 virtual wxSize GetCheckBitmapSize() const
342 { return wxSize(13, 13); }
343 virtual wxSize GetRadioBitmapSize() const
344 { return wxSize(12, 12); }
345 virtual wxCoord GetCheckItemMargin() const
346 { return 0; }
347
348 virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
349 const wxRect& rect);
350 virtual wxRect GetTextClientArea(const wxTextCtrl *text,
351 const wxRect& rect,
352 wxCoord *extraSpaceBeyond);
353
354 virtual wxSize GetTabIndent() const { return wxSize(2, 2); }
355 virtual wxSize GetTabPadding() const { return wxSize(6, 5); }
356
357 virtual wxCoord GetSliderDim() const { return 20; }
358 virtual wxCoord GetSliderTickLen() const { return 4; }
359 virtual wxRect GetSliderShaftRect(const wxRect& rect,
360 wxOrientation orient) const;
361 virtual wxSize GetSliderThumbSize(const wxRect& rect,
362 wxOrientation orient) const;
363 virtual wxSize GetProgressBarStep() const { return wxSize(16, 32); }
364
365 virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const;
366 virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
367 const wxMenu& menu) const;
368
369 virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const;
370
371 protected:
372 // helper of DrawLabel() and DrawCheckOrRadioButton()
373 void DoDrawLabel(wxDC& dc,
374 const wxString& label,
375 const wxRect& rect,
376 int flags = 0,
377 int alignment = wxALIGN_LEFT | wxALIGN_TOP,
378 int indexAccel = -1,
379 wxRect *rectBounds = NULL,
380 const wxPoint& focusOffset
381 = wxPoint(FOCUS_RECT_OFFSET_X, FOCUS_RECT_OFFSET_Y));
382
383 // common part of DrawLabel() and DrawItem()
384 void DrawFocusRect(wxDC& dc, const wxRect& rect);
385
386 // DrawLabel() and DrawButtonLabel() helper
387 void DrawLabelShadow(wxDC& dc,
388 const wxString& label,
389 const wxRect& rect,
390 int alignment,
391 int indexAccel);
392
393 // DrawButtonBorder() helper
394 void DoDrawBackground(wxDC& dc,
395 const wxColour& col,
396 const wxRect& rect);
397
398 // DrawBorder() helpers: all of them shift and clip the DC after drawing
399 // the border
400
401 // just draw a rectangle with the given pen
402 void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
403
404 // draw the lower left part of rectangle
405 void DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen);
406
407 // draw the rectange using the first brush for the left and top sides and
408 // the second one for the bottom and right ones
409 void DrawShadedRect(wxDC& dc, wxRect *rect,
410 const wxPen& pen1, const wxPen& pen2);
411
412 // draw the normal 3D border
413 void DrawRaisedBorder(wxDC& dc, wxRect *rect);
414
415 // draw the sunken 3D border
416 void DrawSunkenBorder(wxDC& dc, wxRect *rect);
417
418 // draw the border used for scrollbar arrows
419 void DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed = FALSE);
420
421 // public DrawArrow()s helper
422 void DrawArrow(wxDC& dc, const wxRect& rect,
423 wxArrowDirection arrowDir, wxArrowStyle arrowStyle);
424
425 // DrawArrowButton is used by DrawScrollbar and DrawComboButton
426 void DrawArrowButton(wxDC& dc, const wxRect& rect,
427 wxArrowDirection arrowDir,
428 wxArrowStyle arrowStyle);
429
430 // DrawCheckButton/DrawRadioButton helper
431 void DrawCheckOrRadioButton(wxDC& dc,
432 const wxString& label,
433 const wxBitmap& bitmap,
434 const wxRect& rect,
435 int flags,
436 wxAlignment align,
437 int indexAccel,
438 wxCoord focusOffsetY);
439
440 // draw a normal or transposed line (useful for using the same code fo both
441 // horizontal and vertical widgets)
442 void DrawLine(wxDC& dc,
443 wxCoord x1, wxCoord y1,
444 wxCoord x2, wxCoord y2,
445 bool transpose = FALSE)
446 {
447 if ( transpose )
448 dc.DrawLine(y1, x1, y2, x2);
449 else
450 dc.DrawLine(x1, y1, x2, y2);
451 }
452
453 // get the standard check/radio button bitmap
454 wxBitmap GetIndicator(IndicatorType indType, int flags);
455 wxBitmap GetCheckBitmap(int flags)
456 { return GetIndicator(IndicatorType_Check, flags); }
457 wxBitmap GetRadioBitmap(int flags)
458 { return GetIndicator(IndicatorType_Radio, flags); }
459
460 private:
461 const wxColourScheme *m_scheme;
462
463 // the sizing parameters (TODO make them changeable)
464 wxSize m_sizeScrollbarArrow;
465
466 // GDI objects we use for drawing
467 wxColour m_colDarkGrey,
468 m_colHighlight;
469
470 wxPen m_penBlack,
471 m_penDarkGrey,
472 m_penLightGrey,
473 m_penHighlight;
474
475 wxFont m_titlebarFont;
476
477 // titlebar icons:
478 wxBitmap m_bmpFrameButtons[FrameButton_Max];
479
480 // first row is for the normal state, second - for the disabled
481 wxBitmap m_bmpArrows[Arrow_StateMax][Arrow_Max];
482 };
483
484 // ----------------------------------------------------------------------------
485 // wxWin32InputHandler and derived classes: process the keyboard and mouse
486 // messages according to Windows standards
487 // ----------------------------------------------------------------------------
488
489 class wxWin32InputHandler : public wxInputHandler
490 {
491 public:
492 wxWin32InputHandler(wxWin32Renderer *renderer);
493
494 virtual bool HandleKey(wxInputConsumer *control,
495 const wxKeyEvent& event,
496 bool pressed);
497 virtual bool HandleMouse(wxInputConsumer *control,
498 const wxMouseEvent& event);
499
500 protected:
501 wxWin32Renderer *m_renderer;
502 };
503
504 class wxWin32ScrollBarInputHandler : public wxStdScrollBarInputHandler
505 {
506 public:
507 wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
508 wxInputHandler *handler);
509
510 virtual bool HandleMouse(wxInputConsumer *control, const wxMouseEvent& event);
511 virtual bool HandleMouseMove(wxInputConsumer *control, const wxMouseEvent& event);
512
513 virtual bool OnScrollTimer(wxScrollBar *scrollbar,
514 const wxControlAction& action);
515
516 protected:
517 virtual bool IsAllowedButton(int button) { return button == 1; }
518
519 virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
520 {
521 // we don't highlight anything
522 }
523
524 // the first and last event which caused the thumb to move
525 wxMouseEvent m_eventStartDrag,
526 m_eventLastDrag;
527
528 // have we paused the scrolling because the mouse moved?
529 bool m_scrollPaused;
530
531 // we remember the interval of the timer to be able to restart it
532 int m_interval;
533 };
534
535 class wxWin32CheckboxInputHandler : public wxStdCheckboxInputHandler
536 {
537 public:
538 wxWin32CheckboxInputHandler(wxInputHandler *handler)
539 : wxStdCheckboxInputHandler(handler) { }
540
541 virtual bool HandleKey(wxInputConsumer *control,
542 const wxKeyEvent& event,
543 bool pressed);
544 };
545
546 class wxWin32TextCtrlInputHandler : public wxStdTextCtrlInputHandler
547 {
548 public:
549 wxWin32TextCtrlInputHandler(wxInputHandler *handler)
550 : wxStdTextCtrlInputHandler(handler) { }
551
552 virtual bool HandleKey(wxInputConsumer *control,
553 const wxKeyEvent& event,
554 bool pressed);
555 };
556
557 class wxWin32StatusBarInputHandler : public wxStdInputHandler
558 {
559 public:
560 wxWin32StatusBarInputHandler(wxInputHandler *handler);
561
562 virtual bool HandleMouse(wxInputConsumer *consumer,
563 const wxMouseEvent& event);
564
565 virtual bool HandleMouseMove(wxInputConsumer *consumer,
566 const wxMouseEvent& event);
567
568 protected:
569 // is the given point over the statusbar grip?
570 bool IsOnGrip(wxWindow *statbar, const wxPoint& pt) const;
571
572 private:
573 // the cursor we had replaced with the resize one
574 wxCursor m_cursorOld;
575
576 // was the mouse over the grip last time we checked?
577 bool m_isOnGrip;
578 };
579
580 // ----------------------------------------------------------------------------
581 // wxWin32ColourScheme: uses (default) Win32 colours
582 // ----------------------------------------------------------------------------
583
584 class wxWin32ColourScheme : public wxColourScheme
585 {
586 public:
587 virtual wxColour Get(StdColour col) const;
588 virtual wxColour GetBackground(wxWindow *win) const;
589 };
590
591 // ----------------------------------------------------------------------------
592 // wxWin32Theme
593 // ----------------------------------------------------------------------------
594
595 WX_DEFINE_ARRAY(wxInputHandler *, wxArrayHandlers);
596
597 class wxWin32Theme : public wxTheme
598 {
599 public:
600 wxWin32Theme();
601 virtual ~wxWin32Theme();
602
603 virtual wxRenderer *GetRenderer();
604 virtual wxInputHandler *GetInputHandler(const wxString& control);
605 virtual wxColourScheme *GetColourScheme();
606
607 private:
608 // get the default input handler
609 wxInputHandler *GetDefaultInputHandler();
610
611 wxWin32Renderer *m_renderer;
612
613 // the names of the already created handlers and the handlers themselves
614 // (these arrays are synchronized)
615 wxSortedArrayString m_handlerNames;
616 wxArrayHandlers m_handlers;
617
618 wxWin32InputHandler *m_handlerDefault;
619
620 wxWin32ColourScheme *m_scheme;
621
622 WX_DECLARE_THEME(win32)
623 };
624
625 // ----------------------------------------------------------------------------
626 // standard bitmaps
627 // ----------------------------------------------------------------------------
628
629 // frame buttons bitmaps
630
631 static const char *frame_button_close_xpm[] = {
632 "12 10 2 1",
633 " c None",
634 ". c black",
635 " ",
636 " .. .. ",
637 " .. .. ",
638 " .... ",
639 " .. ",
640 " .... ",
641 " .. .. ",
642 " .. .. ",
643 " ",
644 " "};
645
646 static const char *frame_button_help_xpm[] = {
647 "12 10 2 1",
648 " c None",
649 ". c #000000",
650 " .... ",
651 " .. .. ",
652 " .. .. ",
653 " .. ",
654 " .. ",
655 " .. ",
656 " ",
657 " .. ",
658 " .. ",
659 " "};
660
661 static const char *frame_button_maximize_xpm[] = {
662 "12 10 2 1",
663 " c None",
664 ". c #000000",
665 " ......... ",
666 " ......... ",
667 " . . ",
668 " . . ",
669 " . . ",
670 " . . ",
671 " . . ",
672 " . . ",
673 " ......... ",
674 " "};
675
676 static const char *frame_button_minimize_xpm[] = {
677 "12 10 2 1",
678 " c None",
679 ". c #000000",
680 " ",
681 " ",
682 " ",
683 " ",
684 " ",
685 " ",
686 " ",
687 " ...... ",
688 " ...... ",
689 " "};
690
691 static const char *frame_button_restore_xpm[] = {
692 "12 10 2 1",
693 " c None",
694 ". c #000000",
695 " ...... ",
696 " ...... ",
697 " . . ",
698 " ...... . ",
699 " ...... . ",
700 " . ... ",
701 " . . ",
702 " . . ",
703 " ...... ",
704 " "};
705
706 // menu bitmaps
707
708 static const char *checked_menu_xpm[] = {
709 /* columns rows colors chars-per-pixel */
710 "9 9 2 1",
711 "w c None",
712 "b c black",
713 /* pixels */
714 "wwwwwwwww",
715 "wwwwwwwbw",
716 "wwwwwwbbw",
717 "wbwwwbbbw",
718 "wbbwbbbww",
719 "wbbbbbwww",
720 "wwbbbwwww",
721 "wwwbwwwww",
722 "wwwwwwwww"
723 };
724
725 static const char *selected_checked_menu_xpm[] = {
726 /* columns rows colors chars-per-pixel */
727 "9 9 2 1",
728 "w c None",
729 "b c white",
730 /* pixels */
731 "wwwwwwwww",
732 "wwwwwwwbw",
733 "wwwwwwbbw",
734 "wbwwwbbbw",
735 "wbbwbbbww",
736 "wbbbbbwww",
737 "wwbbbwwww",
738 "wwwbwwwww",
739 "wwwwwwwww"
740 };
741
742 static const char *disabled_checked_menu_xpm[] = {
743 /* columns rows colors chars-per-pixel */
744 "9 9 3 1",
745 "w c None",
746 "b c #7f7f7f",
747 "W c #e0e0e0",
748 /* pixels */
749 "wwwwwwwww",
750 "wwwwwwwbw",
751 "wwwwwwbbW",
752 "wbwwwbbbW",
753 "wbbwbbbWW",
754 "wbbbbbWWw",
755 "wwbbbWWww",
756 "wwwbWWwww",
757 "wwwwWwwww"
758 };
759
760 static const char *selected_disabled_checked_menu_xpm[] = {
761 /* columns rows colors chars-per-pixel */
762 "9 9 2 1",
763 "w c None",
764 "b c #7f7f7f",
765 /* pixels */
766 "wwwwwwwww",
767 "wwwwwwwbw",
768 "wwwwwwbbw",
769 "wbwwwbbbw",
770 "wbbwbbbww",
771 "wbbbbbwww",
772 "wwbbbwwww",
773 "wwwbwwwww",
774 "wwwwwwwww"
775 };
776
777 // checkbox and radiobox bitmaps below
778
779 static const char *checked_xpm[] = {
780 /* columns rows colors chars-per-pixel */
781 "13 13 5 1",
782 "w c white",
783 "b c black",
784 "d c #7f7f7f",
785 "g c #c0c0c0",
786 "h c #e0e0e0",
787 /* pixels */
788 "ddddddddddddh",
789 "dbbbbbbbbbbgh",
790 "dbwwwwwwwwwgh",
791 "dbwwwwwwwbwgh",
792 "dbwwwwwwbbwgh",
793 "dbwbwwwbbbwgh",
794 "dbwbbwbbbwwgh",
795 "dbwbbbbbwwwgh",
796 "dbwwbbbwwwwgh",
797 "dbwwwbwwwwwgh",
798 "dbwwwwwwwwwgh",
799 "dgggggggggggh",
800 "hhhhhhhhhhhhh"
801 };
802
803 static const char *pressed_checked_xpm[] = {
804 /* columns rows colors chars-per-pixel */
805 "13 13 4 1",
806 "b c black",
807 "d c #7f7f7f",
808 "g c #c0c0c0",
809 "h c #e0e0e0",
810 /* pixels */
811 "ddddddddddddh",
812 "dbbbbbbbbbbgh",
813 "dbggggggggggh",
814 "dbgggggggbggh",
815 "dbggggggbbggh",
816 "dbgbgggbbbggh",
817 "dbgbbgbbbgggh",
818 "dbgbbbbbggggh",
819 "dbggbbbgggggh",
820 "dbgggbggggggh",
821 "dbggggggggggh",
822 "dgggggggggggh",
823 "hhhhhhhhhhhhh"
824 };
825
826 static const char *pressed_disabled_checked_xpm[] = {
827 /* columns rows colors chars-per-pixel */
828 "13 13 4 1",
829 "b c black",
830 "d c #7f7f7f",
831 "g c #c0c0c0",
832 "h c #e0e0e0",
833 /* pixels */
834 "ddddddddddddh",
835 "dbbbbbbbbbbgh",
836 "dbggggggggggh",
837 "dbgggggggdggh",
838 "dbggggggddggh",
839 "dbgdgggdddggh",
840 "dbgddgdddgggh",
841 "dbgdddddggggh",
842 "dbggdddgggggh",
843 "dbgggdggggggh",
844 "dbggggggggggh",
845 "dgggggggggggh",
846 "hhhhhhhhhhhhh"
847 };
848
849 static const char *checked_item_xpm[] = {
850 /* columns rows colors chars-per-pixel */
851 "13 13 3 1",
852 "w c white",
853 "b c black",
854 "d c #808080",
855 /* pixels */
856 "wwwwwwwwwwwww",
857 "wdddddddddddw",
858 "wdwwwwwwwwwdw",
859 "wdwwwwwwwbwdw",
860 "wdwwwwwwbbwdw",
861 "wdwbwwwbbbwdw",
862 "wdwbbwbbbwwdw",
863 "wdwbbbbbwwwdw",
864 "wdwwbbbwwwwdw",
865 "wdwwwbwwwwwdw",
866 "wdwwwwwwwwwdw",
867 "wdddddddddddw",
868 "wwwwwwwwwwwww"
869 };
870
871 static const char *unchecked_xpm[] = {
872 /* columns rows colors chars-per-pixel */
873 "13 13 5 1",
874 "w c white",
875 "b c black",
876 "d c #7f7f7f",
877 "g c #c0c0c0",
878 "h c #e0e0e0",
879 /* pixels */
880 "ddddddddddddh",
881 "dbbbbbbbbbbgh",
882 "dbwwwwwwwwwgh",
883 "dbwwwwwwwwwgh",
884 "dbwwwwwwwwwgh",
885 "dbwwwwwwwwwgh",
886 "dbwwwwwwwwwgh",
887 "dbwwwwwwwwwgh",
888 "dbwwwwwwwwwgh",
889 "dbwwwwwwwwwgh",
890 "dbwwwwwwwwwgh",
891 "dgggggggggggh",
892 "hhhhhhhhhhhhh"
893 };
894
895 static const char *pressed_unchecked_xpm[] = {
896 /* columns rows colors chars-per-pixel */
897 "13 13 4 1",
898 "b c black",
899 "d c #7f7f7f",
900 "g c #c0c0c0",
901 "h c #e0e0e0",
902 /* pixels */
903 "ddddddddddddh",
904 "dbbbbbbbbbbgh",
905 "dbggggggggggh",
906 "dbggggggggggh",
907 "dbggggggggggh",
908 "dbggggggggggh",
909 "dbggggggggggh",
910 "dbggggggggggh",
911 "dbggggggggggh",
912 "dbggggggggggh",
913 "dbggggggggggh",
914 "dbggggggggggh",
915 "hhhhhhhhhhhhh"
916 };
917
918 static const char *unchecked_item_xpm[] = {
919 /* columns rows colors chars-per-pixel */
920 "13 13 2 1",
921 "w c white",
922 "d c #808080",
923 /* pixels */
924 "wwwwwwwwwwwww",
925 "wdddddddddddw",
926 "wdwwwwwwwwwdw",
927 "wdwwwwwwwwwdw",
928 "wdwwwwwwwwwdw",
929 "wdwwwwwwwwwdw",
930 "wdwwwwwwwwwdw",
931 "wdwwwwwwwwwdw",
932 "wdwwwwwwwwwdw",
933 "wdwwwwwwwwwdw",
934 "wdwwwwwwwwwdw",
935 "wdddddddddddw",
936 "wwwwwwwwwwwww"
937 };
938
939 static const char *checked_radio_xpm[] = {
940 /* columns rows colors chars-per-pixel */
941 "12 12 6 1",
942 " c None",
943 "w c white",
944 "b c black",
945 "d c #7f7f7f",
946 "g c #c0c0c0",
947 "h c #e0e0e0",
948 /* pixels */
949 " dddd ",
950 " ddbbbbdd ",
951 " dbbwwwwbbh ",
952 " dbwwwwwwgh ",
953 "dbwwwbbwwwgh",
954 "dbwwbbbbwwgh",
955 "dbwwbbbbwwgh",
956 "dbwwwbbwwwgh",
957 " dbwwwwwwgh ",
958 " dggwwwwggh ",
959 " hhgggghh ",
960 " hhhh "
961 };
962
963 static const char *pressed_checked_radio_xpm[] = {
964 /* columns rows colors chars-per-pixel */
965 "12 12 6 1",
966 " c None",
967 "w c white",
968 "b c black",
969 "d c #7f7f7f",
970 "g c #c0c0c0",
971 "h c #e0e0e0",
972 /* pixels */
973 " dddd ",
974 " ddbbbbdd ",
975 " dbbggggbbh ",
976 " dbgggggggh ",
977 "dbgggbbggggh",
978 "dbggbbbbgggh",
979 "dbggbbbbgggh",
980 "dbgggbbggggh",
981 " dbgggggggh ",
982 " dggggggggh ",
983 " hhgggghh ",
984 " hhhh "
985 };
986
987 static const char *pressed_disabled_checked_radio_xpm[] = {
988 /* columns rows colors chars-per-pixel */
989 "12 12 6 1",
990 " c None",
991 "w c white",
992 "b c black",
993 "d c #7f7f7f",
994 "g c #c0c0c0",
995 "h c #e0e0e0",
996 /* pixels */
997 " dddd ",
998 " ddbbbbdd ",
999 " dbbggggbbh ",
1000 " dbgggggggh ",
1001 "dbgggddggggh",
1002 "dbggddddgggh",
1003 "dbggddddgggh",
1004 "dbgggddggggh",
1005 " dbgggggggh ",
1006 " dggggggggh ",
1007 " hhgggghh ",
1008 " hhhh ",
1009 };
1010
1011 static const char *unchecked_radio_xpm[] = {
1012 /* columns rows colors chars-per-pixel */
1013 "12 12 6 1",
1014 " c None",
1015 "w c white",
1016 "b c black",
1017 "d c #7f7f7f",
1018 "g c #c0c0c0",
1019 "h c #e0e0e0",
1020 /* pixels */
1021 " dddd ",
1022 " ddbbbbdd ",
1023 " dbbwwwwbbh ",
1024 " dbwwwwwwgh ",
1025 "dbwwwwwwwwgh",
1026 "dbwwwwwwwwgh",
1027 "dbwwwwwwwwgh",
1028 "dbwwwwwwwwgh",
1029 " dbwwwwwwgh ",
1030 " dggwwwwggh ",
1031 " hhgggghh ",
1032 " hhhh "
1033 };
1034
1035 static const char *pressed_unchecked_radio_xpm[] = {
1036 /* columns rows colors chars-per-pixel */
1037 "12 12 6 1",
1038 " c None",
1039 "w c white",
1040 "b c black",
1041 "d c #7f7f7f",
1042 "g c #c0c0c0",
1043 "h c #e0e0e0",
1044 /* pixels */
1045 " dddd ",
1046 " ddbbbbdd ",
1047 " dbbggggbbh ",
1048 " dbgggggggh ",
1049 "dbgggggggggh",
1050 "dbgggggggggh",
1051 "dbgggggggggh",
1052 "dbgggggggggh",
1053 " dbgggggggh ",
1054 " dggggggggh ",
1055 " hhgggghh ",
1056 " hhhh "
1057 };
1058
1059 static const char **
1060 bmpIndicators[IndicatorType_Max][IndicatorState_Max][IndicatorStatus_Max] =
1061 {
1062 // checkboxes first
1063 {
1064 // normal state
1065 { checked_xpm, unchecked_xpm },
1066
1067 // pressed state
1068 { pressed_checked_xpm, pressed_unchecked_xpm },
1069
1070 // disabled state
1071 { pressed_disabled_checked_xpm, pressed_unchecked_xpm },
1072 },
1073
1074 // radio
1075 {
1076 // normal state
1077 { checked_radio_xpm, unchecked_radio_xpm },
1078
1079 // pressed state
1080 { pressed_checked_radio_xpm, pressed_unchecked_radio_xpm },
1081
1082 // disabled state
1083 { pressed_disabled_checked_radio_xpm, pressed_unchecked_radio_xpm },
1084 },
1085
1086 // menu
1087 {
1088 // normal state
1089 { checked_menu_xpm, NULL },
1090
1091 // selected state
1092 { selected_checked_menu_xpm, NULL },
1093
1094 // disabled state
1095 { disabled_checked_menu_xpm, NULL },
1096
1097 // disabled selected state
1098 { selected_disabled_checked_menu_xpm, NULL },
1099 }
1100 };
1101
1102 // ============================================================================
1103 // implementation
1104 // ============================================================================
1105
1106 WX_IMPLEMENT_THEME(wxWin32Theme, win32, wxTRANSLATE("Win32 theme"));
1107
1108 // ----------------------------------------------------------------------------
1109 // wxWin32Theme
1110 // ----------------------------------------------------------------------------
1111
1112 wxWin32Theme::wxWin32Theme()
1113 {
1114 m_scheme = NULL;
1115 m_renderer = NULL;
1116 m_handlerDefault = NULL;
1117 }
1118
1119 wxWin32Theme::~wxWin32Theme()
1120 {
1121 size_t count = m_handlers.GetCount();
1122 for ( size_t n = 0; n < count; n++ )
1123 {
1124 if ( m_handlers[n] != m_handlerDefault )
1125 delete m_handlers[n];
1126 }
1127
1128 delete m_handlerDefault;
1129
1130 delete m_renderer;
1131 delete m_scheme;
1132 }
1133
1134 wxRenderer *wxWin32Theme::GetRenderer()
1135 {
1136 if ( !m_renderer )
1137 {
1138 m_renderer = new wxWin32Renderer(GetColourScheme());
1139 }
1140
1141 return m_renderer;
1142 }
1143
1144 wxInputHandler *wxWin32Theme::GetDefaultInputHandler()
1145 {
1146 if ( !m_handlerDefault )
1147 {
1148 m_handlerDefault = new wxWin32InputHandler(m_renderer);
1149 }
1150
1151 return m_handlerDefault;
1152 }
1153
1154 wxInputHandler *wxWin32Theme::GetInputHandler(const wxString& control)
1155 {
1156 wxInputHandler *handler;
1157 int n = m_handlerNames.Index(control);
1158 if ( n == wxNOT_FOUND )
1159 {
1160 // create a new handler
1161 if ( control == wxINP_HANDLER_SCROLLBAR )
1162 handler = new wxWin32ScrollBarInputHandler(m_renderer,
1163 GetDefaultInputHandler());
1164 #if wxUSE_BUTTON
1165 else if ( control == wxINP_HANDLER_BUTTON )
1166 handler = new wxStdButtonInputHandler(GetDefaultInputHandler());
1167 #endif // wxUSE_BUTTON
1168 #if wxUSE_CHECKBOX
1169 else if ( control == wxINP_HANDLER_CHECKBOX )
1170 handler = new wxWin32CheckboxInputHandler(GetDefaultInputHandler());
1171 #endif // wxUSE_CHECKBOX
1172 #if wxUSE_COMBOBOX
1173 else if ( control == wxINP_HANDLER_COMBOBOX )
1174 handler = new wxStdComboBoxInputHandler(GetDefaultInputHandler());
1175 #endif // wxUSE_COMBOBOX
1176 #if wxUSE_LISTBOX
1177 else if ( control == wxINP_HANDLER_LISTBOX )
1178 handler = new wxStdListboxInputHandler(GetDefaultInputHandler());
1179 #endif // wxUSE_LISTBOX
1180 #if wxUSE_CHECKLISTBOX
1181 else if ( control == wxINP_HANDLER_CHECKLISTBOX )
1182 handler = new wxStdCheckListboxInputHandler(GetDefaultInputHandler());
1183 #endif // wxUSE_CHECKLISTBOX
1184 #if wxUSE_TEXTCTRL
1185 else if ( control == wxINP_HANDLER_TEXTCTRL )
1186 handler = new wxWin32TextCtrlInputHandler(GetDefaultInputHandler());
1187 #endif // wxUSE_TEXTCTRL
1188 #if wxUSE_SLIDER
1189 else if ( control == wxINP_HANDLER_SLIDER )
1190 handler = new wxStdSliderButtonInputHandler(GetDefaultInputHandler());
1191 #endif // wxUSE_SLIDER
1192 #if wxUSE_SPINBTN
1193 else if ( control == wxINP_HANDLER_SPINBTN )
1194 handler = new wxStdSpinButtonInputHandler(GetDefaultInputHandler());
1195 #endif // wxUSE_SPINBTN
1196 #if wxUSE_NOTEBOOK
1197 else if ( control == wxINP_HANDLER_NOTEBOOK )
1198 handler = new wxStdNotebookInputHandler(GetDefaultInputHandler());
1199 #endif // wxUSE_NOTEBOOK
1200 #if wxUSE_STATUSBAR
1201 else if ( control == wxINP_HANDLER_STATUSBAR )
1202 handler = new wxWin32StatusBarInputHandler(GetDefaultInputHandler());
1203 #endif // wxUSE_STATUSBAR
1204 else if ( control == wxINP_HANDLER_TOPLEVEL )
1205 handler = new wxStdFrameInputHandler(GetDefaultInputHandler());
1206 else
1207 handler = GetDefaultInputHandler();
1208
1209 n = m_handlerNames.Add(control);
1210 m_handlers.Insert(handler, n);
1211 }
1212 else // we already have it
1213 {
1214 handler = m_handlers[n];
1215 }
1216
1217 return handler;
1218 }
1219
1220 wxColourScheme *wxWin32Theme::GetColourScheme()
1221 {
1222 if ( !m_scheme )
1223 {
1224 m_scheme = new wxWin32ColourScheme;
1225 }
1226 return m_scheme;
1227 }
1228
1229 // ============================================================================
1230 // wxWin32ColourScheme
1231 // ============================================================================
1232
1233 wxColour wxWin32ColourScheme::GetBackground(wxWindow *win) const
1234 {
1235 wxColour col;
1236 if ( win->UseBgCol() )
1237 {
1238 // use the user specified colour
1239 col = win->GetBackgroundColour();
1240 }
1241
1242 if ( win->IsContainerWindow() )
1243 {
1244 wxTextCtrl *text = wxDynamicCast(win, wxTextCtrl);
1245 if ( text )
1246 {
1247 if ( !text->IsEnabled() ) // not IsEditable()
1248 col = Get(CONTROL);
1249 //else: execute code below
1250 }
1251
1252 if ( !col.Ok() )
1253 {
1254 // doesn't depend on the state
1255 col = Get(WINDOW);
1256 }
1257 }
1258 else
1259 {
1260 int flags = win->GetStateFlags();
1261
1262 // the colour set by the user should be used for the normal state
1263 // and for the states for which we don't have any specific colours
1264 if ( !col.Ok() || (flags != 0) )
1265 {
1266 if ( wxDynamicCast(win, wxScrollBar) )
1267 col = Get(flags & wxCONTROL_PRESSED ? SCROLLBAR_PRESSED
1268 : SCROLLBAR);
1269 else
1270 col = Get(CONTROL);
1271 }
1272 }
1273
1274 return col;
1275 }
1276
1277 wxColour wxWin32ColourScheme::Get(wxWin32ColourScheme::StdColour col) const
1278 {
1279 switch ( col )
1280 {
1281 // use the system colours under Windows
1282 #if defined(__WXMSW__)
1283 case WINDOW: return wxColour(GetSysColor(COLOR_WINDOW));
1284
1285 case CONTROL_PRESSED:
1286 case CONTROL_CURRENT:
1287 case CONTROL: return wxColour(GetSysColor(COLOR_BTNFACE));
1288
1289 case CONTROL_TEXT: return wxColour(GetSysColor(COLOR_BTNTEXT));
1290
1291 case SCROLLBAR: return wxColour(GetSysColor(COLOR_SCROLLBAR));
1292 case SCROLLBAR_PRESSED: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
1293
1294 case HIGHLIGHT: return wxColour(GetSysColor(COLOR_HIGHLIGHT));
1295 case HIGHLIGHT_TEXT: return wxColour(GetSysColor(COLOR_HIGHLIGHTTEXT));
1296
1297 #if defined(COLOR_3DDKSHADOW)
1298 case SHADOW_DARK: return wxColour(GetSysColor(COLOR_3DDKSHADOW));
1299 #else
1300 case SHADOW_DARK: return *wxBLACK;
1301 #endif
1302
1303 case CONTROL_TEXT_DISABLED:
1304 case SHADOW_HIGHLIGHT: return wxColour(GetSysColor(COLOR_BTNHIGHLIGHT));
1305
1306 case SHADOW_IN: return wxColour(GetSysColor(COLOR_BTNFACE));
1307
1308 case CONTROL_TEXT_DISABLED_SHADOW:
1309 case SHADOW_OUT: return wxColour(GetSysColor(COLOR_BTNSHADOW));
1310
1311 case TITLEBAR: return wxColour(GetSysColor(COLOR_INACTIVECAPTION));
1312 case TITLEBAR_ACTIVE: return wxColour(GetSysColor(COLOR_ACTIVECAPTION));
1313 case TITLEBAR_TEXT: return wxColour(GetSysColor(COLOR_INACTIVECAPTIONTEXT));
1314 case TITLEBAR_ACTIVE_TEXT: return wxColour(GetSysColor(COLOR_CAPTIONTEXT));
1315
1316 case DESKTOP: return wxColour(0x808000);
1317 #else // !__WXMSW__
1318 // use the standard Windows colours elsewhere
1319 case WINDOW: return *wxWHITE;
1320
1321 case CONTROL_PRESSED:
1322 case CONTROL_CURRENT:
1323 case CONTROL: return wxColour(0xc0c0c0);
1324
1325 case CONTROL_TEXT: return *wxBLACK;
1326
1327 case SCROLLBAR: return wxColour(0xe0e0e0);
1328 case SCROLLBAR_PRESSED: return *wxBLACK;
1329
1330 case HIGHLIGHT: return wxColour(0x800000);
1331 case HIGHLIGHT_TEXT: return wxColour(0xffffff);
1332
1333 case SHADOW_DARK: return *wxBLACK;
1334
1335 case CONTROL_TEXT_DISABLED:return wxColour(0xe0e0e0);
1336 case SHADOW_HIGHLIGHT: return wxColour(0xffffff);
1337
1338 case SHADOW_IN: return wxColour(0xc0c0c0);
1339
1340 case CONTROL_TEXT_DISABLED_SHADOW:
1341 case SHADOW_OUT: return wxColour(0x7f7f7f);
1342
1343 case TITLEBAR: return wxColour(0xaeaaae);
1344 case TITLEBAR_ACTIVE: return wxColour(0x820300);
1345 case TITLEBAR_TEXT: return wxColour(0xc0c0c0);
1346 case TITLEBAR_ACTIVE_TEXT:return *wxWHITE;
1347
1348 case DESKTOP: return wxColour(0x808000);
1349 #endif // __WXMSW__
1350
1351 case MAX:
1352 default:
1353 wxFAIL_MSG(_T("invalid standard colour"));
1354 return *wxBLACK;
1355 }
1356 }
1357
1358 // ============================================================================
1359 // wxWin32Renderer
1360 // ============================================================================
1361
1362 // ----------------------------------------------------------------------------
1363 // construction
1364 // ----------------------------------------------------------------------------
1365
1366 wxWin32Renderer::wxWin32Renderer(const wxColourScheme *scheme)
1367 {
1368 // init data
1369 m_scheme = scheme;
1370 m_sizeScrollbarArrow = wxSize(16, 16);
1371
1372 // init colours and pens
1373 m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK), 0, wxSOLID);
1374
1375 m_colDarkGrey = wxSCHEME_COLOUR(scheme, SHADOW_OUT);
1376 m_penDarkGrey = wxPen(m_colDarkGrey, 0, wxSOLID);
1377
1378 m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN), 0, wxSOLID);
1379
1380 m_colHighlight = wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT);
1381 m_penHighlight = wxPen(m_colHighlight, 0, wxSOLID);
1382
1383 m_titlebarFont = wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
1384 m_titlebarFont.SetWeight(wxFONTWEIGHT_BOLD);
1385
1386 // init the arrow bitmaps
1387 static const size_t ARROW_WIDTH = 7;
1388 static const size_t ARROW_LENGTH = 4;
1389
1390 wxMask *mask;
1391 wxMemoryDC dcNormal,
1392 dcDisabled,
1393 dcInverse;
1394 for ( size_t n = 0; n < Arrow_Max; n++ )
1395 {
1396 bool isVertical = n > Arrow_Right;
1397 int w, h;
1398 if ( isVertical )
1399 {
1400 w = ARROW_WIDTH;
1401 h = ARROW_LENGTH;
1402 }
1403 else
1404 {
1405 h = ARROW_WIDTH;
1406 w = ARROW_LENGTH;
1407 }
1408
1409 // disabled arrow is larger because of the shadow
1410 m_bmpArrows[Arrow_Normal][n].Create(w, h);
1411 m_bmpArrows[Arrow_Disabled][n].Create(w + 1, h + 1);
1412
1413 dcNormal.SelectObject(m_bmpArrows[Arrow_Normal][n]);
1414 dcDisabled.SelectObject(m_bmpArrows[Arrow_Disabled][n]);
1415
1416 dcNormal.SetBackground(*wxWHITE_BRUSH);
1417 dcDisabled.SetBackground(*wxWHITE_BRUSH);
1418 dcNormal.Clear();
1419 dcDisabled.Clear();
1420
1421 dcNormal.SetPen(m_penBlack);
1422 dcDisabled.SetPen(m_penDarkGrey);
1423
1424 // calculate the position of the point of the arrow
1425 wxCoord x1, y1;
1426 if ( isVertical )
1427 {
1428 x1 = (ARROW_WIDTH - 1)/2;
1429 y1 = n == Arrow_Up ? 0 : ARROW_LENGTH - 1;
1430 }
1431 else // horizontal
1432 {
1433 x1 = n == Arrow_Left ? 0 : ARROW_LENGTH - 1;
1434 y1 = (ARROW_WIDTH - 1)/2;
1435 }
1436
1437 wxCoord x2 = x1,
1438 y2 = y1;
1439
1440 if ( isVertical )
1441 x2++;
1442 else
1443 y2++;
1444
1445 for ( size_t i = 0; i < ARROW_LENGTH; i++ )
1446 {
1447 dcNormal.DrawLine(x1, y1, x2, y2);
1448 dcDisabled.DrawLine(x1, y1, x2, y2);
1449
1450 if ( isVertical )
1451 {
1452 x1--;
1453 x2++;
1454
1455 if ( n == Arrow_Up )
1456 {
1457 y1++;
1458 y2++;
1459 }
1460 else // down arrow
1461 {
1462 y1--;
1463 y2--;
1464 }
1465 }
1466 else // left or right arrow
1467 {
1468 y1--;
1469 y2++;
1470
1471 if ( n == Arrow_Left )
1472 {
1473 x1++;
1474 x2++;
1475 }
1476 else
1477 {
1478 x1--;
1479 x2--;
1480 }
1481 }
1482 }
1483
1484 // draw the shadow for the disabled one
1485 dcDisabled.SetPen(m_penHighlight);
1486 switch ( n )
1487 {
1488 case Arrow_Left:
1489 y1 += 2;
1490 dcDisabled.DrawLine(x1, y1, x2, y2);
1491 break;
1492
1493 case Arrow_Right:
1494 x1 = ARROW_LENGTH - 1;
1495 y1 = (ARROW_WIDTH - 1)/2 + 1;
1496 x2 = 0;
1497 y2 = ARROW_WIDTH;
1498 dcDisabled.DrawLine(x1, y1, x2, y2);
1499 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1500 break;
1501
1502 case Arrow_Up:
1503 x1 += 2;
1504 dcDisabled.DrawLine(x1, y1, x2, y2);
1505 break;
1506
1507 case Arrow_Down:
1508 x1 = ARROW_WIDTH - 1;
1509 y1 = 1;
1510 x2 = (ARROW_WIDTH - 1)/2;
1511 y2 = ARROW_LENGTH;
1512 dcDisabled.DrawLine(x1, y1, x2, y2);
1513 dcDisabled.DrawLine(++x1, y1, x2, ++y2);
1514 break;
1515
1516 }
1517
1518 // create the inversed bitmap but only for the right arrow as we only
1519 // use it for the menus
1520 if ( n == Arrow_Right )
1521 {
1522 m_bmpArrows[Arrow_Inversed][n].Create(w, h);
1523 dcInverse.SelectObject(m_bmpArrows[Arrow_Inversed][n]);
1524 dcInverse.Clear();
1525 dcInverse.Blit(0, 0, w, h,
1526 &dcNormal, 0, 0,
1527 wxXOR);
1528 dcInverse.SelectObject(wxNullBitmap);
1529
1530 mask = new wxMask(m_bmpArrows[Arrow_Inversed][n], *wxBLACK);
1531 m_bmpArrows[Arrow_Inversed][n].SetMask(mask);
1532
1533 m_bmpArrows[Arrow_InversedDisabled][n].Create(w, h);
1534 dcInverse.SelectObject(m_bmpArrows[Arrow_InversedDisabled][n]);
1535 dcInverse.Clear();
1536 dcInverse.Blit(0, 0, w, h,
1537 &dcDisabled, 0, 0,
1538 wxXOR);
1539 dcInverse.SelectObject(wxNullBitmap);
1540
1541 mask = new wxMask(m_bmpArrows[Arrow_InversedDisabled][n], *wxBLACK);
1542 m_bmpArrows[Arrow_InversedDisabled][n].SetMask(mask);
1543 }
1544
1545 dcNormal.SelectObject(wxNullBitmap);
1546 dcDisabled.SelectObject(wxNullBitmap);
1547
1548 mask = new wxMask(m_bmpArrows[Arrow_Normal][n], *wxWHITE);
1549 m_bmpArrows[Arrow_Normal][n].SetMask(mask);
1550 mask = new wxMask(m_bmpArrows[Arrow_Disabled][n], *wxWHITE);
1551 m_bmpArrows[Arrow_Disabled][n].SetMask(mask);
1552
1553 m_bmpArrows[Arrow_Pressed][n] = m_bmpArrows[Arrow_Normal][n];
1554 }
1555
1556 // init the frame buttons bitmaps
1557 m_bmpFrameButtons[FrameButton_Close] = wxBitmap(frame_button_close_xpm);
1558 m_bmpFrameButtons[FrameButton_Minimize] = wxBitmap(frame_button_minimize_xpm);
1559 m_bmpFrameButtons[FrameButton_Maximize] = wxBitmap(frame_button_maximize_xpm);
1560 m_bmpFrameButtons[FrameButton_Restore] = wxBitmap(frame_button_restore_xpm);
1561 m_bmpFrameButtons[FrameButton_Help] = wxBitmap(frame_button_help_xpm);
1562 }
1563
1564 // ----------------------------------------------------------------------------
1565 // border stuff
1566 // ----------------------------------------------------------------------------
1567
1568 /*
1569 The raised border in Win32 looks like this:
1570
1571 IIIIIIIIIIIIIIIIIIIIIIB
1572 I GB
1573 I GB I = white (HILIGHT)
1574 I GB H = light grey (LIGHT)
1575 I GB G = dark grey (SHADOI)
1576 I GB B = black (DKSHADOI)
1577 I GB I = hIghlight (COLOR_3DHILIGHT)
1578 I GB
1579 IGGGGGGGGGGGGGGGGGGGGGB
1580 BBBBBBBBBBBBBBBBBBBBBBB
1581
1582 The sunken border looks like this:
1583
1584 GGGGGGGGGGGGGGGGGGGGGGI
1585 GBBBBBBBBBBBBBBBBBBBBHI
1586 GB HI
1587 GB HI
1588 GB HI
1589 GB HI
1590 GB HI
1591 GB HI
1592 GHHHHHHHHHHHHHHHHHHHHHI
1593 IIIIIIIIIIIIIIIIIIIIIII
1594
1595 The static border (used for the controls which don't get focus) is like
1596 this:
1597
1598 GGGGGGGGGGGGGGGGGGGGGGW
1599 G W
1600 G W
1601 G W
1602 G W
1603 G W
1604 G W
1605 G W
1606 WWWWWWWWWWWWWWWWWWWWWWW
1607
1608 The most complicated is the double border:
1609
1610 HHHHHHHHHHHHHHHHHHHHHHB
1611 HWWWWWWWWWWWWWWWWWWWWGB
1612 HWHHHHHHHHHHHHHHHHHHHGB
1613 HWH HGB
1614 HWH HGB
1615 HWH HGB
1616 HWH HGB
1617 HWHHHHHHHHHHHHHHHHHHHGB
1618 HGGGGGGGGGGGGGGGGGGGGGB
1619 BBBBBBBBBBBBBBBBBBBBBBB
1620
1621 And the simple border is, well, simple:
1622
1623 BBBBBBBBBBBBBBBBBBBBBBB
1624 B B
1625 B B
1626 B B
1627 B B
1628 B B
1629 B B
1630 B B
1631 B B
1632 BBBBBBBBBBBBBBBBBBBBBBB
1633 */
1634
1635 void wxWin32Renderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1636 {
1637 // draw
1638 dc.SetPen(pen);
1639 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1640 dc.DrawRectangle(*rect);
1641
1642 // adjust the rect
1643 rect->Inflate(-1);
1644 }
1645
1646 void wxWin32Renderer::DrawHalfRect(wxDC& dc, wxRect *rect, const wxPen& pen)
1647 {
1648 // draw the bottom and right sides
1649 dc.SetPen(pen);
1650 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1651 rect->GetRight() + 1, rect->GetBottom());
1652 dc.DrawLine(rect->GetRight(), rect->GetTop(),
1653 rect->GetRight(), rect->GetBottom());
1654
1655 // adjust the rect
1656 rect->width--;
1657 rect->height--;
1658 }
1659
1660 void wxWin32Renderer::DrawShadedRect(wxDC& dc, wxRect *rect,
1661 const wxPen& pen1, const wxPen& pen2)
1662 {
1663 // draw the rectangle
1664 dc.SetPen(pen1);
1665 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
1666 rect->GetLeft(), rect->GetBottom());
1667 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
1668 rect->GetRight(), rect->GetTop());
1669 dc.SetPen(pen2);
1670 dc.DrawLine(rect->GetRight(), rect->GetTop(),
1671 rect->GetRight(), rect->GetBottom());
1672 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
1673 rect->GetRight() + 1, rect->GetBottom());
1674
1675 // adjust the rect
1676 rect->Inflate(-1);
1677 }
1678
1679 void wxWin32Renderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
1680 {
1681 DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
1682 DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
1683 }
1684
1685 void wxWin32Renderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
1686 {
1687 DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
1688 DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
1689 }
1690
1691 void wxWin32Renderer::DrawArrowBorder(wxDC& dc, wxRect *rect, bool isPressed)
1692 {
1693 if ( isPressed )
1694 {
1695 DrawRect(dc, rect, m_penDarkGrey);
1696
1697 // the arrow is usually drawn inside border of width 2 and is offset by
1698 // another pixel in both directions when it's pressed - as the border
1699 // in this case is more narrow as well, we have to adjust rect like
1700 // this:
1701 rect->Inflate(-1);
1702 rect->x++;
1703 rect->y++;
1704 }
1705 else
1706 {
1707 DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
1708 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
1709 }
1710 }
1711
1712 void wxWin32Renderer::DrawBorder(wxDC& dc,
1713 wxBorder border,
1714 const wxRect& rectTotal,
1715 int WXUNUSED(flags),
1716 wxRect *rectIn)
1717 {
1718 int i;
1719
1720 wxRect rect = rectTotal;
1721
1722 switch ( border )
1723 {
1724 case wxBORDER_SUNKEN:
1725 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1726 {
1727 DrawSunkenBorder(dc, &rect);
1728 }
1729 break;
1730
1731 case wxBORDER_STATIC:
1732 DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
1733 break;
1734
1735 case wxBORDER_RAISED:
1736 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1737 {
1738 DrawRaisedBorder(dc, &rect);
1739 }
1740 break;
1741
1742 case wxBORDER_DOUBLE:
1743 DrawArrowBorder(dc, &rect);
1744 DrawRect(dc, &rect, m_penLightGrey);
1745 break;
1746
1747 case wxBORDER_SIMPLE:
1748 for ( i = 0; i < BORDER_THICKNESS / 2; i++ )
1749 {
1750 DrawRect(dc, &rect, m_penBlack);
1751 }
1752 break;
1753
1754 default:
1755 wxFAIL_MSG(_T("unknown border type"));
1756 // fall through
1757
1758 case wxBORDER_DEFAULT:
1759 case wxBORDER_NONE:
1760 break;
1761 }
1762
1763 if ( rectIn )
1764 *rectIn = rect;
1765 }
1766
1767 wxRect wxWin32Renderer::GetBorderDimensions(wxBorder border) const
1768 {
1769 wxCoord width;
1770 switch ( border )
1771 {
1772 case wxBORDER_RAISED:
1773 case wxBORDER_SUNKEN:
1774 width = BORDER_THICKNESS;
1775 break;
1776
1777 case wxBORDER_SIMPLE:
1778 case wxBORDER_STATIC:
1779 width = 1;
1780 break;
1781
1782 case wxBORDER_DOUBLE:
1783 width = 3;
1784 break;
1785
1786 default:
1787 wxFAIL_MSG(_T("unknown border type"));
1788 // fall through
1789
1790 case wxBORDER_DEFAULT:
1791 case wxBORDER_NONE:
1792 width = 0;
1793 break;
1794 }
1795
1796 wxRect rect;
1797 rect.x =
1798 rect.y =
1799 rect.width =
1800 rect.height = width;
1801
1802 return rect;
1803 }
1804
1805 bool wxWin32Renderer::AreScrollbarsInsideBorder() const
1806 {
1807 return TRUE;
1808 }
1809
1810 // ----------------------------------------------------------------------------
1811 // borders
1812 // ----------------------------------------------------------------------------
1813
1814 void wxWin32Renderer::DrawTextBorder(wxDC& dc,
1815 wxBorder border,
1816 const wxRect& rect,
1817 int flags,
1818 wxRect *rectIn)
1819 {
1820 // text controls are not special under windows
1821 DrawBorder(dc, border, rect, flags, rectIn);
1822 }
1823
1824 void wxWin32Renderer::DrawButtonBorder(wxDC& dc,
1825 const wxRect& rectTotal,
1826 int flags,
1827 wxRect *rectIn)
1828 {
1829 wxRect rect = rectTotal;
1830
1831 if ( flags & wxCONTROL_PRESSED )
1832 {
1833 // button pressed: draw a double border around it
1834 DrawRect(dc, &rect, m_penBlack);
1835 DrawRect(dc, &rect, m_penDarkGrey);
1836 }
1837 else
1838 {
1839 // button not pressed
1840
1841 if ( flags & (wxCONTROL_FOCUSED | wxCONTROL_ISDEFAULT) )
1842 {
1843 // button either default or focused (or both): add an extra border around it
1844 DrawRect(dc, &rect, m_penBlack);
1845 }
1846
1847 // now draw a normal button
1848 DrawShadedRect(dc, &rect, m_penHighlight, m_penBlack);
1849 DrawHalfRect(dc, &rect, m_penDarkGrey);
1850 }
1851
1852 if ( rectIn )
1853 {
1854 *rectIn = rect;
1855 }
1856 }
1857
1858 // ----------------------------------------------------------------------------
1859 // lines and frame
1860 // ----------------------------------------------------------------------------
1861
1862 void wxWin32Renderer::DrawHorizontalLine(wxDC& dc,
1863 wxCoord y, wxCoord x1, wxCoord x2)
1864 {
1865 dc.SetPen(m_penDarkGrey);
1866 dc.DrawLine(x1, y, x2 + 1, y);
1867 dc.SetPen(m_penHighlight);
1868 y++;
1869 dc.DrawLine(x1, y, x2 + 1, y);
1870 }
1871
1872 void wxWin32Renderer::DrawVerticalLine(wxDC& dc,
1873 wxCoord x, wxCoord y1, wxCoord y2)
1874 {
1875 dc.SetPen(m_penDarkGrey);
1876 dc.DrawLine(x, y1, x, y2 + 1);
1877 dc.SetPen(m_penHighlight);
1878 x++;
1879 dc.DrawLine(x, y1, x, y2 + 1);
1880 }
1881
1882 void wxWin32Renderer::DrawFrame(wxDC& dc,
1883 const wxString& label,
1884 const wxRect& rect,
1885 int flags,
1886 int alignment,
1887 int indexAccel)
1888 {
1889 wxCoord height = 0; // of the label
1890 wxRect rectFrame = rect;
1891 if ( !label.empty() )
1892 {
1893 // the text should touch the top border of the rect, so the frame
1894 // itself should be lower
1895 dc.GetTextExtent(label, NULL, &height);
1896 rectFrame.y += height / 2;
1897 rectFrame.height -= height / 2;
1898
1899 // we have to draw each part of the frame individually as we can't
1900 // erase the background beyond the label as it might contain some
1901 // pixmap already, so drawing everything and then overwriting part of
1902 // the frame with label doesn't work
1903
1904 // TODO: the +5 and space insertion should be customizable
1905
1906 wxRect rectText;
1907 rectText.x = rectFrame.x + 5;
1908 rectText.y = rect.y;
1909 rectText.width = rectFrame.width - 7; // +2 border width
1910 rectText.height = height;
1911
1912 wxString label2;
1913 label2 << _T(' ') << label << _T(' ');
1914 if ( indexAccel != -1 )
1915 {
1916 // adjust it as we prepended a space
1917 indexAccel++;
1918 }
1919
1920 wxRect rectLabel;
1921 DrawLabel(dc, label2, rectText, flags, alignment, indexAccel, &rectLabel);
1922
1923 StandardDrawFrame(dc, rectFrame, rectLabel);
1924 }
1925 else
1926 {
1927 // just draw the complete frame
1928 DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
1929 DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
1930 }
1931 }
1932
1933 // ----------------------------------------------------------------------------
1934 // label
1935 // ----------------------------------------------------------------------------
1936
1937 void wxWin32Renderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
1938 {
1939 // VZ: this doesn't work under Windows, the dotted pen has dots of 3
1940 // pixels each while we really need dots here... PS_ALTERNATE might
1941 // work, but it is for NT 5 only
1942 #if 0
1943 DrawRect(dc, &rect, wxPen(*wxBLACK, 0, wxDOT));
1944 #else
1945 // draw the pixels manually: note that to behave in the same manner as
1946 // DrawRect(), we must exclude the bottom and right borders from the
1947 // rectangle
1948 wxCoord x1 = rect.GetLeft(),
1949 y1 = rect.GetTop(),
1950 x2 = rect.GetRight(),
1951 y2 = rect.GetBottom();
1952
1953 dc.SetPen(wxPen(*wxBLACK, 0, wxSOLID));
1954
1955 // this seems to be closer than what Windows does than wxINVERT although
1956 // I'm still not sure if it's correct
1957 dc.SetLogicalFunction(wxAND_REVERSE);
1958
1959 wxCoord z;
1960 for ( z = x1 + 1; z < x2; z += 2 )
1961 dc.DrawPoint(z, rect.GetTop());
1962
1963 wxCoord shift = z == x2 ? 0 : 1;
1964 for ( z = y1 + shift; z < y2; z += 2 )
1965 dc.DrawPoint(x2, z);
1966
1967 shift = z == y2 ? 0 : 1;
1968 for ( z = x2 - shift; z > x1; z -= 2 )
1969 dc.DrawPoint(z, y2);
1970
1971 shift = z == x1 ? 0 : 1;
1972 for ( z = y2 - shift; z > y1; z -= 2 )
1973 dc.DrawPoint(x1, z);
1974
1975 dc.SetLogicalFunction(wxCOPY);
1976 #endif // 0/1
1977 }
1978
1979 void wxWin32Renderer::DrawLabelShadow(wxDC& dc,
1980 const wxString& label,
1981 const wxRect& rect,
1982 int alignment,
1983 int indexAccel)
1984 {
1985 // draw shadow of the text
1986 dc.SetTextForeground(m_colHighlight);
1987 wxRect rectShadow = rect;
1988 rectShadow.x++;
1989 rectShadow.y++;
1990 dc.DrawLabel(label, rectShadow, alignment, indexAccel);
1991
1992 // make the text grey
1993 dc.SetTextForeground(m_colDarkGrey);
1994 }
1995
1996 void wxWin32Renderer::DrawLabel(wxDC& dc,
1997 const wxString& label,
1998 const wxRect& rect,
1999 int flags,
2000 int alignment,
2001 int indexAccel,
2002 wxRect *rectBounds)
2003 {
2004 DoDrawLabel(dc, label, rect, flags, alignment, indexAccel, rectBounds);
2005 }
2006
2007 void wxWin32Renderer::DoDrawLabel(wxDC& dc,
2008 const wxString& label,
2009 const wxRect& rect,
2010 int flags,
2011 int alignment,
2012 int indexAccel,
2013 wxRect *rectBounds,
2014 const wxPoint& focusOffset)
2015 {
2016 // the underscores are not drawn for focused controls in wxMSW
2017 if ( flags & wxCONTROL_FOCUSED )
2018 {
2019 indexAccel = -1;
2020 }
2021
2022 if ( flags & wxCONTROL_DISABLED )
2023 {
2024 // the combination of wxCONTROL_SELECTED and wxCONTROL_DISABLED
2025 // currently only can happen for a menu item and it seems that Windows
2026 // doesn't draw the shadow in this case, so we don't do it neither
2027 if ( flags & wxCONTROL_SELECTED )
2028 {
2029 // just make the label text greyed out
2030 dc.SetTextForeground(m_colDarkGrey);
2031 }
2032 else // draw normal disabled label
2033 {
2034 DrawLabelShadow(dc, label, rect, alignment, indexAccel);
2035 }
2036 }
2037
2038 wxRect rectLabel;
2039 dc.DrawLabel(label, wxNullBitmap, rect, alignment, indexAccel, &rectLabel);
2040
2041 if ( flags & wxCONTROL_DISABLED )
2042 {
2043 // restore the fg colour
2044 dc.SetTextForeground(*wxBLACK);
2045 }
2046
2047 if ( flags & wxCONTROL_FOCUSED )
2048 {
2049 if ( focusOffset.x || focusOffset.y )
2050 {
2051 rectLabel.Inflate(focusOffset.x, focusOffset.y);
2052 }
2053
2054 DrawFocusRect(dc, rectLabel);
2055 }
2056
2057 if ( rectBounds )
2058 *rectBounds = rectLabel;
2059 }
2060
2061 void wxWin32Renderer::DrawButtonLabel(wxDC& dc,
2062 const wxString& label,
2063 const wxBitmap& image,
2064 const wxRect& rect,
2065 int flags,
2066 int alignment,
2067 int indexAccel,
2068 wxRect *rectBounds)
2069 {
2070 // the underscores are not drawn for focused controls in wxMSW
2071 if ( flags & wxCONTROL_PRESSED )
2072 {
2073 indexAccel = -1;
2074 }
2075
2076 wxRect rectLabel = rect;
2077 if ( !label.empty() )
2078 {
2079 // shift the label if a button is pressed
2080 if ( flags & wxCONTROL_PRESSED )
2081 {
2082 rectLabel.x++;
2083 rectLabel.y++;
2084 }
2085
2086 if ( flags & wxCONTROL_DISABLED )
2087 {
2088 DrawLabelShadow(dc, label, rectLabel, alignment, indexAccel);
2089 }
2090
2091 // leave enough space for the focus rectangle
2092 if ( flags & wxCONTROL_FOCUSED )
2093 {
2094 rectLabel.Inflate(-2);
2095 }
2096 }
2097
2098 dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
2099
2100 if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
2101 {
2102 if ( flags & wxCONTROL_PRESSED )
2103 {
2104 // the focus rectangle is never pressed, so undo the shift done
2105 // above
2106 rectLabel.x--;
2107 rectLabel.y--;
2108 rectLabel.width--;
2109 rectLabel.height--;
2110 }
2111
2112 DrawFocusRect(dc, rectLabel);
2113 }
2114 }
2115
2116 // ----------------------------------------------------------------------------
2117 // (check)listbox items
2118 // ----------------------------------------------------------------------------
2119
2120 void wxWin32Renderer::DrawItem(wxDC& dc,
2121 const wxString& label,
2122 const wxRect& rect,
2123 int flags)
2124 {
2125 wxDCTextColourChanger colChanger(dc);
2126
2127 if ( flags & wxCONTROL_SELECTED )
2128 {
2129 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2130
2131 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2132 dc.SetBrush(wxBrush(colBg, wxSOLID));
2133 dc.SetPen(wxPen(colBg, 0, wxSOLID));
2134 dc.DrawRectangle(rect);
2135 }
2136
2137 wxRect rectText = rect;
2138 rectText.x += 2;
2139 rectText.width -= 2;
2140 dc.DrawLabel(label, wxNullBitmap, rectText);
2141
2142 if ( flags & wxCONTROL_FOCUSED )
2143 {
2144 DrawFocusRect(dc, rect);
2145 }
2146 }
2147
2148 void wxWin32Renderer::DrawCheckItem(wxDC& dc,
2149 const wxString& label,
2150 const wxBitmap& bitmap,
2151 const wxRect& rect,
2152 int flags)
2153 {
2154 wxBitmap bmp;
2155 if ( bitmap.Ok() )
2156 {
2157 bmp = bitmap;
2158 }
2159 else // use default bitmap
2160 {
2161 bmp = wxBitmap(flags & wxCONTROL_CHECKED ? checked_item_xpm
2162 : unchecked_item_xpm);
2163 }
2164
2165 dc.DrawBitmap(bmp, rect.x, rect.y + (rect.height - bmp.GetHeight()) / 2 - 1,
2166 TRUE /* use mask */);
2167
2168 wxRect rectLabel = rect;
2169 int bmpWidth = bmp.GetWidth();
2170 rectLabel.x += bmpWidth;
2171 rectLabel.width -= bmpWidth;
2172
2173 DrawItem(dc, label, rectLabel, flags);
2174 }
2175
2176 // ----------------------------------------------------------------------------
2177 // check/radio buttons
2178 // ----------------------------------------------------------------------------
2179
2180 wxBitmap wxWin32Renderer::GetIndicator(IndicatorType indType, int flags)
2181 {
2182 IndicatorState indState;
2183 if ( flags & wxCONTROL_SELECTED )
2184 indState = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
2185 : IndicatorState_Selected;
2186 else if ( flags & wxCONTROL_DISABLED )
2187 indState = IndicatorState_Disabled;
2188 else if ( flags & wxCONTROL_PRESSED )
2189 indState = IndicatorState_Pressed;
2190 else
2191 indState = IndicatorState_Normal;
2192
2193 IndicatorStatus indStatus = flags & wxCONTROL_CHECKED
2194 ? IndicatorStatus_Checked
2195 : IndicatorStatus_Unchecked;
2196
2197 const char **xpm = bmpIndicators[indType][indState][indStatus];
2198 if (xpm)
2199 {
2200 wxBitmap bmp(xpm);
2201 return bmp;
2202 }
2203 else
2204 return wxNullBitmap;
2205 }
2206
2207 void wxWin32Renderer::DrawCheckOrRadioButton(wxDC& dc,
2208 const wxString& label,
2209 const wxBitmap& bitmap,
2210 const wxRect& rect,
2211 int flags,
2212 wxAlignment align,
2213 int indexAccel,
2214 wxCoord focusOffsetY)
2215 {
2216 // calculate the position of the bitmap and of the label
2217 wxCoord heightBmp = bitmap.GetHeight();
2218 wxCoord xBmp,
2219 yBmp = rect.y + (rect.height - heightBmp) / 2;
2220
2221 wxRect rectLabel;
2222 dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
2223 rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
2224
2225 // align label vertically with the bitmap - looks nicer like this
2226 rectLabel.y -= (rectLabel.height - heightBmp) % 2;
2227
2228 // calc horz position
2229 if ( align == wxALIGN_RIGHT )
2230 {
2231 xBmp = rect.GetRight() - bitmap.GetWidth();
2232 rectLabel.x = rect.x + 3;
2233 rectLabel.SetRight(xBmp);
2234 }
2235 else // normal (checkbox to the left of the text) case
2236 {
2237 xBmp = rect.x;
2238 rectLabel.x = xBmp + bitmap.GetWidth() + 5;
2239 rectLabel.SetRight(rect.GetRight());
2240 }
2241
2242 // THIS IS THE CULPRIT -- JACS
2243 dc.DrawBitmap(bitmap, xBmp, yBmp, TRUE /* use mask */);
2244
2245 DoDrawLabel(
2246 dc, label, rectLabel,
2247 flags,
2248 wxALIGN_LEFT | wxALIGN_TOP,
2249 indexAccel,
2250 NULL, // we don't need bounding rect
2251 // use custom vert focus rect offset
2252 wxPoint(FOCUS_RECT_OFFSET_X, focusOffsetY)
2253 );
2254 }
2255
2256 void wxWin32Renderer::DrawRadioButton(wxDC& dc,
2257 const wxString& label,
2258 const wxBitmap& bitmap,
2259 const wxRect& rect,
2260 int flags,
2261 wxAlignment align,
2262 int indexAccel)
2263 {
2264 if (bitmap.Ok())
2265 DrawCheckOrRadioButton(dc, label,
2266 bitmap,
2267 rect, flags, align, indexAccel,
2268 FOCUS_RECT_OFFSET_Y); // default focus rect offset
2269 else
2270 {
2271 wxBitmap rbitmap(GetRadioBitmap(flags));
2272 DrawCheckOrRadioButton(dc, label,
2273 rbitmap,
2274 rect, flags, align, indexAccel,
2275 FOCUS_RECT_OFFSET_Y); // default focus rect offset
2276 }
2277 }
2278
2279 void wxWin32Renderer::DrawCheckButton(wxDC& dc,
2280 const wxString& label,
2281 const wxBitmap& bitmap,
2282 const wxRect& rect,
2283 int flags,
2284 wxAlignment align,
2285 int indexAccel)
2286 {
2287 if (bitmap.Ok())
2288 DrawCheckOrRadioButton(dc, label,
2289 bitmap,
2290 rect, flags, align, indexAccel,
2291 0); // no focus rect offset for checkboxes
2292 else
2293 {
2294 wxBitmap cbitmap(GetCheckBitmap(flags));
2295 #if 1
2296 DrawCheckOrRadioButton(dc, label,
2297 cbitmap,
2298 rect, flags, align, indexAccel,
2299 0); // no focus rect offset for checkboxes
2300 #endif
2301 }
2302 }
2303
2304 // ----------------------------------------------------------------------------
2305 // text control
2306 // ----------------------------------------------------------------------------
2307
2308 void wxWin32Renderer::DrawTextLine(wxDC& dc,
2309 const wxString& text,
2310 const wxRect& rect,
2311 int selStart,
2312 int selEnd,
2313 int flags)
2314 {
2315 // nothing special to do here
2316 StandardDrawTextLine(dc, text, rect, selStart, selEnd, flags);
2317 }
2318
2319 void wxWin32Renderer::DrawLineWrapMark(wxDC& dc, const wxRect& rect)
2320 {
2321 // we don't draw them
2322 }
2323
2324 // ----------------------------------------------------------------------------
2325 // notebook
2326 // ----------------------------------------------------------------------------
2327
2328 void wxWin32Renderer::DrawTab(wxDC& dc,
2329 const wxRect& rectOrig,
2330 wxDirection dir,
2331 const wxString& label,
2332 const wxBitmap& bitmap,
2333 int flags,
2334 int indexAccel)
2335 {
2336 wxRect rect = rectOrig;
2337
2338 // the current tab is drawn indented (to the top for default case) and
2339 // bigger than the other ones
2340 const wxSize indent = GetTabIndent();
2341 if ( flags & wxCONTROL_SELECTED )
2342 {
2343 switch ( dir )
2344 {
2345 default:
2346 wxFAIL_MSG(_T("invaild notebook tab orientation"));
2347 // fall through
2348
2349 case wxTOP:
2350 rect.Inflate(indent.x, 0);
2351 rect.y -= indent.y;
2352 rect.height += indent.y;
2353 break;
2354
2355 case wxBOTTOM:
2356 rect.Inflate(indent.x, 0);
2357 rect.height += indent.y;
2358 break;
2359
2360 case wxLEFT:
2361 case wxRIGHT:
2362 wxFAIL_MSG(_T("TODO"));
2363 break;
2364 }
2365 }
2366
2367 // draw the text, image and the focus around them (if necessary)
2368 wxRect rectLabel = rect;
2369 rectLabel.Deflate(1, 1);
2370 DrawButtonLabel(dc, label, bitmap, rectLabel,
2371 flags, wxALIGN_CENTRE, indexAccel);
2372
2373 // now draw the tab border itself (maybe use DrawRoundedRectangle()?)
2374 static const wxCoord CUTOFF = 2; // radius of the rounded corner
2375 wxCoord x = rect.x,
2376 y = rect.y,
2377 x2 = rect.GetRight(),
2378 y2 = rect.GetBottom();
2379
2380 // FIXME: all this code will break if the tab indent or the border width,
2381 // it is tied to the fact that both of them are equal to 2
2382 switch ( dir )
2383 {
2384 default:
2385 case wxTOP:
2386 dc.SetPen(m_penHighlight);
2387 dc.DrawLine(x, y2, x, y + CUTOFF);
2388 dc.DrawLine(x, y + CUTOFF, x + CUTOFF, y);
2389 dc.DrawLine(x + CUTOFF, y, x2 - CUTOFF + 1, y);
2390
2391 dc.SetPen(m_penBlack);
2392 dc.DrawLine(x2, y2, x2, y + CUTOFF);
2393 dc.DrawLine(x2, y + CUTOFF, x2 - CUTOFF, y);
2394
2395 dc.SetPen(m_penDarkGrey);
2396 dc.DrawLine(x2 - 1, y2, x2 - 1, y + CUTOFF - 1);
2397
2398 if ( flags & wxCONTROL_SELECTED )
2399 {
2400 dc.SetPen(m_penLightGrey);
2401
2402 // overwrite the part of the border below this tab
2403 dc.DrawLine(x + 1, y2 + 1, x2 - 1, y2 + 1);
2404
2405 // and the shadow of the tab to the left of us
2406 dc.DrawLine(x + 1, y + CUTOFF + 1, x + 1, y2 + 1);
2407 }
2408 break;
2409
2410 case wxBOTTOM:
2411 dc.SetPen(m_penHighlight);
2412 // we need to continue one pixel further to overwrite the corner of
2413 // the border for the selected tab
2414 dc.DrawLine(x, y - (flags & wxCONTROL_SELECTED ? 1 : 0),
2415 x, y2 - CUTOFF);
2416 dc.DrawLine(x, y2 - CUTOFF, x + CUTOFF, y2);
2417
2418 dc.SetPen(m_penBlack);
2419 dc.DrawLine(x + CUTOFF, y2, x2 - CUTOFF + 1, y2);
2420 dc.DrawLine(x2, y, x2, y2 - CUTOFF);
2421 dc.DrawLine(x2, y2 - CUTOFF, x2 - CUTOFF, y2);
2422
2423 dc.SetPen(m_penDarkGrey);
2424 dc.DrawLine(x + CUTOFF, y2 - 1, x2 - CUTOFF + 1, y2 - 1);
2425 dc.DrawLine(x2 - 1, y, x2 - 1, y2 - CUTOFF + 1);
2426
2427 if ( flags & wxCONTROL_SELECTED )
2428 {
2429 dc.SetPen(m_penLightGrey);
2430
2431 // overwrite the part of the (double!) border above this tab
2432 dc.DrawLine(x + 1, y - 1, x2 - 1, y - 1);
2433 dc.DrawLine(x + 1, y - 2, x2 - 1, y - 2);
2434
2435 // and the shadow of the tab to the left of us
2436 dc.DrawLine(x + 1, y2 - CUTOFF, x + 1, y - 1);
2437 }
2438 break;
2439
2440 case wxLEFT:
2441 case wxRIGHT:
2442 wxFAIL_MSG(_T("TODO"));
2443 }
2444 }
2445
2446 // ----------------------------------------------------------------------------
2447 // slider
2448 // ----------------------------------------------------------------------------
2449
2450 wxSize wxWin32Renderer::GetSliderThumbSize(const wxRect& rect,
2451 wxOrientation orient) const
2452 {
2453 wxSize size;
2454
2455 wxRect rectShaft = GetSliderShaftRect(rect, orient);
2456 if ( orient == wxHORIZONTAL )
2457 {
2458 size.y = rect.height - 6;
2459 size.x = wxMin(size.y / 2, rectShaft.width);
2460 }
2461 else // vertical
2462 {
2463 size.x = rect.width - 6;
2464 size.y = wxMin(size.x / 2, rectShaft.height);
2465 }
2466
2467 return size;
2468 }
2469
2470 wxRect wxWin32Renderer::GetSliderShaftRect(const wxRect& rectOrig,
2471 wxOrientation orient) const
2472 {
2473 static const wxCoord SLIDER_MARGIN = 6;
2474
2475 wxRect rect = rectOrig;
2476
2477 if ( orient == wxHORIZONTAL )
2478 {
2479 // make the rect of minimal width and centre it
2480 rect.height = 2*BORDER_THICKNESS;
2481 rect.y = rectOrig.y + (rectOrig.height - rect.height) / 2;
2482 if ( rect.y < 0 )
2483 rect.y = 0;
2484
2485 // leave margins on the sides
2486 rect.Deflate(SLIDER_MARGIN, 0);
2487 }
2488 else // vertical
2489 {
2490 // same as above but in other direction
2491 rect.width = 2*BORDER_THICKNESS;
2492 rect.x = rectOrig.x + (rectOrig.width - rect.width) / 2;
2493 if ( rect.x < 0 )
2494 rect.x = 0;
2495
2496 rect.Deflate(0, SLIDER_MARGIN);
2497 }
2498
2499 return rect;
2500 }
2501
2502 void wxWin32Renderer::DrawSliderShaft(wxDC& dc,
2503 const wxRect& rectOrig,
2504 wxOrientation orient,
2505 int flags,
2506 wxRect *rectShaft)
2507 {
2508 if ( flags & wxCONTROL_FOCUSED )
2509 {
2510 DrawFocusRect(dc, rectOrig);
2511 }
2512
2513 wxRect rect = GetSliderShaftRect(rectOrig, orient);
2514
2515 if ( rectShaft )
2516 *rectShaft = rect;
2517
2518 DrawSunkenBorder(dc, &rect);
2519 }
2520
2521 void wxWin32Renderer::DrawSliderThumb(wxDC& dc,
2522 const wxRect& rect,
2523 wxOrientation orient,
2524 int flags)
2525 {
2526 /*
2527 we are drawing a shape of this form
2528
2529 HHHHHHB <--- y
2530 H DB
2531 H DB
2532 H DB where H is hightlight colour
2533 H DB D dark grey
2534 H DB B black
2535 H DB
2536 H DB <--- y3
2537 H DB
2538 HDB
2539 B <--- y2
2540
2541 ^ ^ ^
2542 | | |
2543 x x3 x2
2544
2545 The interior of this shape is filled with the hatched brush if the thumb
2546 is pressed.
2547 */
2548
2549 DrawBackground(dc, wxNullColour, rect, flags);
2550
2551 bool transpose = orient == wxVERTICAL;
2552
2553 wxCoord x, y, x2, y2;
2554 if ( transpose )
2555 {
2556 x = rect.y;
2557 y = rect.x;
2558 x2 = rect.GetBottom();
2559 y2 = rect.GetRight();
2560 }
2561 else
2562 {
2563 x = rect.x;
2564 y = rect.y;
2565 x2 = rect.GetRight();
2566 y2 = rect.GetBottom();
2567 }
2568
2569 // the size of the pointed part of the thumb
2570 wxCoord sizeArrow = (transpose ? rect.height : rect.width) / 2;
2571
2572 wxCoord x3 = x + sizeArrow,
2573 y3 = y2 - sizeArrow;
2574
2575 dc.SetPen(m_penHighlight);
2576 DrawLine(dc, x, y, x2, y, transpose);
2577 DrawLine(dc, x, y + 1, x, y2 - sizeArrow, transpose);
2578 DrawLine(dc, x, y3, x3, y2, transpose);
2579
2580 dc.SetPen(m_penBlack);
2581 DrawLine(dc, x3, y2, x2, y3, transpose);
2582 DrawLine(dc, x2, y3, x2, y - 1, transpose);
2583
2584 dc.SetPen(m_penDarkGrey);
2585 DrawLine(dc, x3, y2 - 1, x2 - 1, y3, transpose);
2586 DrawLine(dc, x2 - 1, y3, x2 - 1, y, transpose);
2587
2588 if ( flags & wxCONTROL_PRESSED )
2589 {
2590 // TODO: MSW fills the entire area inside, not just the rect
2591 wxRect rectInt = rect;
2592 if ( transpose )
2593 rectInt.SetRight(y3);
2594 else
2595 rectInt.SetBottom(y3);
2596 rectInt.Deflate(2);
2597
2598 #if !defined(__WXMGL__)
2599 static const char *stipple_xpm[] = {
2600 /* columns rows colors chars-per-pixel */
2601 "2 2 2 1",
2602 " c None",
2603 "w c white",
2604 /* pixels */
2605 "w ",
2606 " w",
2607 };
2608 #else
2609 // VS: MGL can only do 8x8 stipple brushes
2610 static const char *stipple_xpm[] = {
2611 /* columns rows colors chars-per-pixel */
2612 "8 8 2 1",
2613 " c None",
2614 "w c white",
2615 /* pixels */
2616 "w w w w ",
2617 " w w w w",
2618 "w w w w ",
2619 " w w w w",
2620 "w w w w ",
2621 " w w w w",
2622 "w w w w ",
2623 " w w w w",
2624 };
2625 #endif
2626 dc.SetBrush(wxBrush(stipple_xpm));
2627
2628 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, SHADOW_HIGHLIGHT));
2629 dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, CONTROL));
2630 dc.SetPen(*wxTRANSPARENT_PEN);
2631 dc.DrawRectangle(rectInt);
2632 }
2633 }
2634
2635 void wxWin32Renderer::DrawSliderTicks(wxDC& dc,
2636 const wxRect& rect,
2637 const wxSize& sizeThumb,
2638 wxOrientation orient,
2639 int start,
2640 int end,
2641 int step,
2642 int flags)
2643 {
2644 if ( end == start )
2645 {
2646 // empty slider?
2647 return;
2648 }
2649
2650 // the variable names correspond to horizontal case, but they can be used
2651 // for both orientations
2652 wxCoord x1, x2, y1, y2, len, widthThumb;
2653 if ( orient == wxHORIZONTAL )
2654 {
2655 x1 = rect.GetLeft();
2656 x2 = rect.GetRight();
2657
2658 // draw from bottom to top to leave one pixel space between the ticks
2659 // and the slider as Windows do
2660 y1 = rect.GetBottom();
2661 y2 = rect.GetTop();
2662
2663 len = rect.width;
2664
2665 widthThumb = sizeThumb.x;
2666 }
2667 else // vertical
2668 {
2669 x1 = rect.GetTop();
2670 x2 = rect.GetBottom();
2671
2672 y1 = rect.GetRight();
2673 y2 = rect.GetLeft();
2674
2675 len = rect.height;
2676
2677 widthThumb = sizeThumb.y;
2678 }
2679
2680 // the first tick should be positioned in such way that a thumb drawn in
2681 // the first position points down directly to it
2682 x1 += widthThumb / 2;
2683 x2 -= widthThumb / 2;
2684
2685 // this also means that we have slightly less space for the ticks in
2686 // between the first and the last
2687 len -= widthThumb;
2688
2689 dc.SetPen(m_penBlack);
2690
2691 int range = end - start;
2692 for ( int n = 0; n < range; n += step )
2693 {
2694 wxCoord x = x1 + (len*n) / range;
2695
2696 DrawLine(dc, x, y1, x, y2, orient == wxVERTICAL);
2697 }
2698
2699 // always draw the line at the end position
2700 DrawLine(dc, x2, y1, x2, y2, orient == wxVERTICAL);
2701 }
2702
2703 // ----------------------------------------------------------------------------
2704 // menu and menubar
2705 // ----------------------------------------------------------------------------
2706
2707 // wxWin32MenuGeometryInfo: the wxMenuGeometryInfo used by wxWin32Renderer
2708 class WXDLLEXPORT wxWin32MenuGeometryInfo : public wxMenuGeometryInfo
2709 {
2710 public:
2711 virtual wxSize GetSize() const { return m_size; }
2712
2713 wxCoord GetLabelOffset() const { return m_ofsLabel; }
2714 wxCoord GetAccelOffset() const { return m_ofsAccel; }
2715
2716 wxCoord GetItemHeight() const { return m_heightItem; }
2717
2718 private:
2719 // the total size of the menu
2720 wxSize m_size;
2721
2722 // the offset of the start of the menu item label
2723 wxCoord m_ofsLabel;
2724
2725 // the offset of the start of the accel label
2726 wxCoord m_ofsAccel;
2727
2728 // the height of a normal (not separator) item
2729 wxCoord m_heightItem;
2730
2731 friend wxMenuGeometryInfo *
2732 wxWin32Renderer::GetMenuGeometry(wxWindow *, const wxMenu&) const;
2733 };
2734
2735 // FIXME: all constants are hardcoded but shouldn't be
2736 static const wxCoord MENU_LEFT_MARGIN = 9;
2737 static const wxCoord MENU_RIGHT_MARGIN = 18;
2738 static const wxCoord MENU_VERT_MARGIN = 3;
2739
2740 // the margin around bitmap/check marks (on each side)
2741 static const wxCoord MENU_BMP_MARGIN = 2;
2742
2743 // the margin between the labels and accel strings
2744 static const wxCoord MENU_ACCEL_MARGIN = 8;
2745
2746 // the separator height in pixels: in fact, strangely enough, the real height
2747 // is 2 but Windows adds one extra pixel in the bottom margin, so take it into
2748 // account here
2749 static const wxCoord MENU_SEPARATOR_HEIGHT = 3;
2750
2751 // the size of the standard checkmark bitmap
2752 static const wxCoord MENU_CHECK_SIZE = 9;
2753
2754 void wxWin32Renderer::DrawMenuBarItem(wxDC& dc,
2755 const wxRect& rectOrig,
2756 const wxString& label,
2757 int flags,
2758 int indexAccel)
2759 {
2760 wxRect rect = rectOrig;
2761 rect.height--;
2762
2763 wxDCTextColourChanger colChanger(dc);
2764
2765 if ( flags & wxCONTROL_SELECTED )
2766 {
2767 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2768
2769 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2770 dc.SetBrush(wxBrush(colBg, wxSOLID));
2771 dc.SetPen(wxPen(colBg, 0, wxSOLID));
2772 dc.DrawRectangle(rect);
2773 }
2774
2775 // don't draw the focus rect around menu bar items
2776 DrawLabel(dc, label, rect, flags & ~wxCONTROL_FOCUSED,
2777 wxALIGN_CENTRE, indexAccel);
2778 }
2779
2780 void wxWin32Renderer::DrawMenuItem(wxDC& dc,
2781 wxCoord y,
2782 const wxMenuGeometryInfo& gi,
2783 const wxString& label,
2784 const wxString& accel,
2785 const wxBitmap& bitmap,
2786 int flags,
2787 int indexAccel)
2788 {
2789 const wxWin32MenuGeometryInfo& geometryInfo =
2790 (const wxWin32MenuGeometryInfo&)gi;
2791
2792 wxRect rect;
2793 rect.x = 0;
2794 rect.y = y;
2795 rect.width = geometryInfo.GetSize().x;
2796 rect.height = geometryInfo.GetItemHeight();
2797
2798 // draw the selected item specially
2799 wxDCTextColourChanger colChanger(dc);
2800 if ( flags & wxCONTROL_SELECTED )
2801 {
2802 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
2803
2804 wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
2805 dc.SetBrush(wxBrush(colBg, wxSOLID));
2806 dc.SetPen(wxPen(colBg, 0, wxSOLID));
2807 dc.DrawRectangle(rect);
2808 }
2809
2810 // draw the bitmap: use the bitmap provided or the standard checkmark for
2811 // the checkable items
2812 wxBitmap bmp = bitmap;
2813 if ( !bmp.Ok() && (flags & wxCONTROL_CHECKED) )
2814 {
2815 bmp = GetIndicator(IndicatorType_Menu, flags);
2816 }
2817
2818 if ( bmp.Ok() )
2819 {
2820 rect.SetRight(geometryInfo.GetLabelOffset());
2821 wxControlRenderer::DrawBitmap(dc, bmp, rect);
2822 }
2823
2824 // draw the label
2825 rect.x = geometryInfo.GetLabelOffset();
2826 rect.SetRight(geometryInfo.GetAccelOffset());
2827
2828 DrawLabel(dc, label, rect, flags, wxALIGN_CENTRE_VERTICAL, indexAccel);
2829
2830 // draw the accel string
2831 rect.x = geometryInfo.GetAccelOffset();
2832 rect.SetRight(geometryInfo.GetSize().x);
2833
2834 // NB: no accel index here
2835 DrawLabel(dc, accel, rect, flags, wxALIGN_CENTRE_VERTICAL);
2836
2837 // draw the submenu indicator
2838 if ( flags & wxCONTROL_ISSUBMENU )
2839 {
2840 rect.x = geometryInfo.GetSize().x - MENU_RIGHT_MARGIN;
2841 rect.width = MENU_RIGHT_MARGIN;
2842
2843 wxArrowStyle arrowStyle;
2844 if ( flags & wxCONTROL_DISABLED )
2845 arrowStyle = flags & wxCONTROL_SELECTED ? Arrow_InversedDisabled
2846 : Arrow_Disabled;
2847 else if ( flags & wxCONTROL_SELECTED )
2848 arrowStyle = Arrow_Inversed;
2849 else
2850 arrowStyle = Arrow_Normal;
2851
2852 DrawArrow(dc, rect, Arrow_Right, arrowStyle);
2853 }
2854 }
2855
2856 void wxWin32Renderer::DrawMenuSeparator(wxDC& dc,
2857 wxCoord y,
2858 const wxMenuGeometryInfo& geomInfo)
2859 {
2860 DrawHorizontalLine(dc, y + MENU_VERT_MARGIN, 0, geomInfo.GetSize().x);
2861 }
2862
2863 wxSize wxWin32Renderer::GetMenuBarItemSize(const wxSize& sizeText) const
2864 {
2865 wxSize size = sizeText;
2866
2867 // FIXME: menubar height is configurable under Windows
2868 size.x += 12;
2869 size.y += 6;
2870
2871 return size;
2872 }
2873
2874 wxMenuGeometryInfo *wxWin32Renderer::GetMenuGeometry(wxWindow *win,
2875 const wxMenu& menu) const
2876 {
2877 // prepare the dc: for now we draw all the items with the system font
2878 wxClientDC dc(win);
2879 dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
2880
2881 // the height of a normal item
2882 wxCoord heightText = dc.GetCharHeight();
2883
2884 // the total height
2885 wxCoord height = 0;
2886
2887 // the max length of label and accel strings: the menu width is the sum of
2888 // them, even if they're for different items (as the accels should be
2889 // aligned)
2890 //
2891 // the max length of the bitmap is never 0 as Windows always leaves enough
2892 // space for a check mark indicator
2893 wxCoord widthLabelMax = 0,
2894 widthAccelMax = 0,
2895 widthBmpMax = MENU_LEFT_MARGIN;
2896
2897 for ( wxMenuItemList::Node *node = menu.GetMenuItems().GetFirst();
2898 node;
2899 node = node->GetNext() )
2900 {
2901 // height of this item
2902 wxCoord h;
2903
2904 wxMenuItem *item = node->GetData();
2905 if ( item->IsSeparator() )
2906 {
2907 h = MENU_SEPARATOR_HEIGHT;
2908 }
2909 else // not separator
2910 {
2911 h = heightText;
2912
2913 wxCoord widthLabel;
2914 dc.GetTextExtent(item->GetLabel(), &widthLabel, NULL);
2915 if ( widthLabel > widthLabelMax )
2916 {
2917 widthLabelMax = widthLabel;
2918 }
2919
2920 wxCoord widthAccel;
2921 dc.GetTextExtent(item->GetAccelString(), &widthAccel, NULL);
2922 if ( widthAccel > widthAccelMax )
2923 {
2924 widthAccelMax = widthAccel;
2925 }
2926
2927 const wxBitmap& bmp = item->GetBitmap();
2928 if ( bmp.Ok() )
2929 {
2930 wxCoord widthBmp = bmp.GetWidth();
2931 if ( widthBmp > widthBmpMax )
2932 widthBmpMax = widthBmp;
2933 }
2934 //else if ( item->IsCheckable() ): no need to check for this as
2935 // MENU_LEFT_MARGIN is big enough to show the check mark
2936 }
2937
2938 h += 2*MENU_VERT_MARGIN;
2939
2940 // remember the item position and height
2941 item->SetGeometry(height, h);
2942
2943 height += h;
2944 }
2945
2946 // bundle the metrics into a struct and return it
2947 wxWin32MenuGeometryInfo *gi = new wxWin32MenuGeometryInfo;
2948
2949 gi->m_ofsLabel = widthBmpMax + 2*MENU_BMP_MARGIN;
2950 gi->m_ofsAccel = gi->m_ofsLabel + widthLabelMax;
2951 if ( widthAccelMax > 0 )
2952 {
2953 // if we actually have any accesl, add a margin
2954 gi->m_ofsAccel += MENU_ACCEL_MARGIN;
2955 }
2956
2957 gi->m_heightItem = heightText + 2*MENU_VERT_MARGIN;
2958
2959 gi->m_size.x = gi->m_ofsAccel + widthAccelMax + MENU_RIGHT_MARGIN;
2960 gi->m_size.y = height;
2961
2962 return gi;
2963 }
2964
2965 // ----------------------------------------------------------------------------
2966 // status bar
2967 // ----------------------------------------------------------------------------
2968
2969 static const wxCoord STATBAR_BORDER_X = 2;
2970 static const wxCoord STATBAR_BORDER_Y = 2;
2971
2972 wxSize wxWin32Renderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
2973 {
2974 if ( borderBetweenFields )
2975 *borderBetweenFields = 2;
2976
2977 return wxSize(STATBAR_BORDER_X, STATBAR_BORDER_Y);
2978 }
2979
2980 void wxWin32Renderer::DrawStatusField(wxDC& dc,
2981 const wxRect& rect,
2982 const wxString& label,
2983 int flags)
2984 {
2985 wxRect rectIn;
2986
2987 if ( flags & wxCONTROL_ISDEFAULT )
2988 {
2989 // draw the size grip: it is a normal rect except that in the lower
2990 // right corner we have several bands which may be used for dragging
2991 // the status bar corner
2992 //
2993 // each band consists of 4 stripes: m_penHighlight, double
2994 // m_penDarkGrey and transparent one
2995 wxCoord x2 = rect.GetRight(),
2996 y2 = rect.GetBottom();
2997
2998 // draw the upper left part of the rect normally
2999 dc.SetPen(m_penDarkGrey);
3000 dc.DrawLine(rect.GetLeft(), rect.GetTop(), rect.GetLeft(), y2);
3001 dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(), x2, rect.GetTop());
3002
3003 // draw the grey stripes of the grip
3004 size_t n;
3005 wxCoord ofs = WIDTH_STATUSBAR_GRIP_BAND - 1;
3006 for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
3007 {
3008 dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
3009 dc.DrawLine(x2 - ofs, y2 - 1, x2, y2 - ofs - 1);
3010 }
3011
3012 // draw the white stripes
3013 dc.SetPen(m_penHighlight);
3014 ofs = WIDTH_STATUSBAR_GRIP_BAND + 1;
3015 for ( n = 0; n < NUM_STATUSBAR_GRIP_BANDS; n++, ofs += WIDTH_STATUSBAR_GRIP_BAND )
3016 {
3017 dc.DrawLine(x2 - ofs + 1, y2 - 1, x2, y2 - ofs);
3018 }
3019
3020 // draw the remaining rect boundaries
3021 ofs -= WIDTH_STATUSBAR_GRIP_BAND;
3022 dc.DrawLine(x2, rect.GetTop(), x2, y2 - ofs + 1);
3023 dc.DrawLine(rect.GetLeft(), y2, x2 - ofs + 1, y2);
3024
3025 rectIn = rect;
3026 rectIn.Deflate(1);
3027
3028 rectIn.width -= STATUSBAR_GRIP_SIZE;
3029 }
3030 else // normal pane
3031 {
3032 DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
3033 }
3034
3035 rectIn.Deflate(STATBAR_BORDER_X, STATBAR_BORDER_Y);
3036
3037 wxDCClipper clipper(dc, rectIn);
3038 DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
3039 }
3040
3041 // ----------------------------------------------------------------------------
3042 // combobox
3043 // ----------------------------------------------------------------------------
3044
3045 void wxWin32Renderer::GetComboBitmaps(wxBitmap *bmpNormal,
3046 wxBitmap *bmpFocus,
3047 wxBitmap *bmpPressed,
3048 wxBitmap *bmpDisabled)
3049 {
3050 static const wxCoord widthCombo = 16;
3051 static const wxCoord heightCombo = 17;
3052
3053 wxMemoryDC dcMem;
3054
3055 if ( bmpNormal )
3056 {
3057 bmpNormal->Create(widthCombo, heightCombo);
3058 dcMem.SelectObject(*bmpNormal);
3059 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3060 Arrow_Down, Arrow_Normal);
3061 }
3062
3063 if ( bmpPressed )
3064 {
3065 bmpPressed->Create(widthCombo, heightCombo);
3066 dcMem.SelectObject(*bmpPressed);
3067 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3068 Arrow_Down, Arrow_Pressed);
3069 }
3070
3071 if ( bmpDisabled )
3072 {
3073 bmpDisabled->Create(widthCombo, heightCombo);
3074 dcMem.SelectObject(*bmpDisabled);
3075 DrawArrowButton(dcMem, wxRect(0, 0, widthCombo, heightCombo),
3076 Arrow_Down, Arrow_Disabled);
3077 }
3078 }
3079
3080 // ----------------------------------------------------------------------------
3081 // background
3082 // ----------------------------------------------------------------------------
3083
3084 void wxWin32Renderer::DoDrawBackground(wxDC& dc,
3085 const wxColour& col,
3086 const wxRect& rect)
3087 {
3088 wxBrush brush(col, wxSOLID);
3089 dc.SetBrush(brush);
3090 dc.SetPen(*wxTRANSPARENT_PEN);
3091 dc.DrawRectangle(rect);
3092 }
3093
3094 void wxWin32Renderer::DrawBackground(wxDC& dc,
3095 const wxColour& col,
3096 const wxRect& rect,
3097 int flags)
3098 {
3099 // just fill it with the given or default bg colour
3100 wxColour colBg = col.Ok() ? col : wxSCHEME_COLOUR(m_scheme, CONTROL);
3101 DoDrawBackground(dc, colBg, rect);
3102 }
3103
3104 // ----------------------------------------------------------------------------
3105 // scrollbar
3106 // ----------------------------------------------------------------------------
3107
3108 void wxWin32Renderer::DrawArrow(wxDC& dc,
3109 wxDirection dir,
3110 const wxRect& rect,
3111 int flags)
3112 {
3113 // get the bitmap for this arrow
3114 wxArrowDirection arrowDir;
3115 switch ( dir )
3116 {
3117 case wxLEFT: arrowDir = Arrow_Left; break;
3118 case wxRIGHT: arrowDir = Arrow_Right; break;
3119 case wxUP: arrowDir = Arrow_Up; break;
3120 case wxDOWN: arrowDir = Arrow_Down; break;
3121
3122 default:
3123 wxFAIL_MSG(_T("unknown arrow direction"));
3124 return;
3125 }
3126
3127 wxArrowStyle arrowStyle;
3128 if ( flags & wxCONTROL_PRESSED )
3129 {
3130 // can't be pressed and disabled
3131 arrowStyle = Arrow_Pressed;
3132 }
3133 else
3134 {
3135 arrowStyle = flags & wxCONTROL_DISABLED ? Arrow_Disabled : Arrow_Normal;
3136 }
3137
3138 DrawArrowButton(dc, rect, arrowDir, arrowStyle);
3139 }
3140
3141 void wxWin32Renderer::DrawArrow(wxDC& dc,
3142 const wxRect& rect,
3143 wxArrowDirection arrowDir,
3144 wxArrowStyle arrowStyle)
3145 {
3146 const wxBitmap& bmp = m_bmpArrows[arrowStyle][arrowDir];
3147
3148 // under Windows the arrows always have the same size so just centre it in
3149 // the provided rectangle
3150 wxCoord x = rect.x + (rect.width - bmp.GetWidth()) / 2,
3151 y = rect.y + (rect.height - bmp.GetHeight()) / 2;
3152
3153 // Windows does it like this...
3154 if ( arrowDir == Arrow_Left )
3155 x--;
3156
3157 // draw it
3158 dc.DrawBitmap(bmp, x, y, TRUE /* use mask */);
3159 }
3160
3161 void wxWin32Renderer::DrawArrowButton(wxDC& dc,
3162 const wxRect& rectAll,
3163 wxArrowDirection arrowDir,
3164 wxArrowStyle arrowStyle)
3165 {
3166 wxRect rect = rectAll;
3167 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
3168 DrawArrowBorder(dc, &rect, arrowStyle == Arrow_Pressed);
3169 DrawArrow(dc, rect, arrowDir, arrowStyle);
3170 }
3171
3172 void wxWin32Renderer::DrawScrollbarThumb(wxDC& dc,
3173 wxOrientation orient,
3174 const wxRect& rect,
3175 int flags)
3176 {
3177 // we don't use the flags, the thumb never changes appearance
3178 wxRect rectThumb = rect;
3179 DrawArrowBorder(dc, &rectThumb);
3180 DrawBackground(dc, wxNullColour, rectThumb);
3181 }
3182
3183 void wxWin32Renderer::DrawScrollbarShaft(wxDC& dc,
3184 wxOrientation orient,
3185 const wxRect& rectBar,
3186 int flags)
3187 {
3188 wxColourScheme::StdColour col = flags & wxCONTROL_PRESSED
3189 ? wxColourScheme::SCROLLBAR_PRESSED
3190 : wxColourScheme::SCROLLBAR;
3191 DoDrawBackground(dc, m_scheme->Get(col), rectBar);
3192 }
3193
3194 void wxWin32Renderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
3195 {
3196 DoDrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
3197 }
3198
3199 wxRect wxWin32Renderer::GetScrollbarRect(const wxScrollBar *scrollbar,
3200 wxScrollBar::Element elem,
3201 int thumbPos) const
3202 {
3203 return StandardGetScrollbarRect(scrollbar, elem,
3204 thumbPos, m_sizeScrollbarArrow);
3205 }
3206
3207 wxCoord wxWin32Renderer::GetScrollbarSize(const wxScrollBar *scrollbar)
3208 {
3209 return StandardScrollBarSize(scrollbar, m_sizeScrollbarArrow);
3210 }
3211
3212 wxHitTest wxWin32Renderer::HitTestScrollbar(const wxScrollBar *scrollbar,
3213 const wxPoint& pt) const
3214 {
3215 return StandardHitTestScrollbar(scrollbar, pt, m_sizeScrollbarArrow);
3216 }
3217
3218 wxCoord wxWin32Renderer::ScrollbarToPixel(const wxScrollBar *scrollbar,
3219 int thumbPos)
3220 {
3221 return StandardScrollbarToPixel(scrollbar, thumbPos, m_sizeScrollbarArrow);
3222 }
3223
3224 int wxWin32Renderer::PixelToScrollbar(const wxScrollBar *scrollbar,
3225 wxCoord coord)
3226 {
3227 return StandardPixelToScrollbar(scrollbar, coord, m_sizeScrollbarArrow);
3228 }
3229
3230 // ----------------------------------------------------------------------------
3231 // top level windows
3232 // ----------------------------------------------------------------------------
3233
3234 int wxWin32Renderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
3235 {
3236 wxRect client = GetFrameClientArea(rect, flags);
3237
3238 if ( client.Inside(pt) )
3239 return wxHT_TOPLEVEL_CLIENT_AREA;
3240
3241 if ( flags & wxTOPLEVEL_TITLEBAR )
3242 {
3243 wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3244
3245 if ( flags & wxTOPLEVEL_ICON )
3246 {
3247 if ( wxRect(client.GetPosition(), GetFrameIconSize()).Inside(pt) )
3248 return wxHT_TOPLEVEL_ICON;
3249 }
3250
3251 wxRect btnRect(client.GetRight() - 2 - FRAME_BUTTON_WIDTH,
3252 client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2,
3253 FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
3254
3255 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3256 {
3257 if ( btnRect.Inside(pt) )
3258 return wxHT_TOPLEVEL_BUTTON_CLOSE;
3259 btnRect.x -= FRAME_BUTTON_WIDTH + 2;
3260 }
3261 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3262 {
3263 if ( btnRect.Inside(pt) )
3264 return wxHT_TOPLEVEL_BUTTON_MAXIMIZE;
3265 btnRect.x -= FRAME_BUTTON_WIDTH;
3266 }
3267 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3268 {
3269 if ( btnRect.Inside(pt) )
3270 return wxHT_TOPLEVEL_BUTTON_RESTORE;
3271 btnRect.x -= FRAME_BUTTON_WIDTH;
3272 }
3273 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3274 {
3275 if ( btnRect.Inside(pt) )
3276 return wxHT_TOPLEVEL_BUTTON_ICONIZE;
3277 btnRect.x -= FRAME_BUTTON_WIDTH;
3278 }
3279 if ( flags & wxTOPLEVEL_BUTTON_HELP )
3280 {
3281 if ( btnRect.Inside(pt) )
3282 return wxHT_TOPLEVEL_BUTTON_HELP;
3283 btnRect.x -= FRAME_BUTTON_WIDTH;
3284 }
3285
3286 if ( pt.y >= client.y && pt.y < client.y + FRAME_TITLEBAR_HEIGHT )
3287 return wxHT_TOPLEVEL_TITLEBAR;
3288 }
3289
3290 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3291 {
3292 // we are certainly at one of borders, lets decide which one:
3293
3294 int border = 0;
3295 // dirty trick, relies on the way wxHT_TOPLEVEL_XXX are defined!
3296 if ( pt.x < client.x )
3297 border |= wxHT_TOPLEVEL_BORDER_W;
3298 else if ( pt.x >= client.width + client.x )
3299 border |= wxHT_TOPLEVEL_BORDER_E;
3300 if ( pt.y < client.y )
3301 border |= wxHT_TOPLEVEL_BORDER_N;
3302 else if ( pt.y >= client.height + client.y )
3303 border |= wxHT_TOPLEVEL_BORDER_S;
3304 return border;
3305 }
3306
3307 return wxHT_NOWHERE;
3308 }
3309
3310 void wxWin32Renderer::DrawFrameTitleBar(wxDC& dc,
3311 const wxRect& rect,
3312 const wxString& title,
3313 const wxIcon& icon,
3314 int flags,
3315 int specialButton,
3316 int specialButtonFlags)
3317 {
3318 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3319 {
3320 DrawFrameBorder(dc, rect, flags);
3321 }
3322 if ( flags & wxTOPLEVEL_TITLEBAR )
3323 {
3324 DrawFrameBackground(dc, rect, flags);
3325 if ( flags & wxTOPLEVEL_ICON )
3326 DrawFrameIcon(dc, rect, icon, flags);
3327 DrawFrameTitle(dc, rect, title, flags);
3328
3329 wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3330 wxCoord x,y;
3331 x = client.GetRight() - 2 - FRAME_BUTTON_WIDTH;
3332 y = client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2;
3333
3334 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
3335 {
3336 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_CLOSE,
3337 (specialButton == wxTOPLEVEL_BUTTON_CLOSE) ?
3338 specialButtonFlags : 0);
3339 x -= FRAME_BUTTON_WIDTH + 2;
3340 }
3341 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
3342 {
3343 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_MAXIMIZE,
3344 (specialButton == wxTOPLEVEL_BUTTON_MAXIMIZE) ?
3345 specialButtonFlags : 0);
3346 x -= FRAME_BUTTON_WIDTH;
3347 }
3348 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
3349 {
3350 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_RESTORE,
3351 (specialButton == wxTOPLEVEL_BUTTON_RESTORE) ?
3352 specialButtonFlags : 0);
3353 x -= FRAME_BUTTON_WIDTH;
3354 }
3355 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
3356 {
3357 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_ICONIZE,
3358 (specialButton == wxTOPLEVEL_BUTTON_ICONIZE) ?
3359 specialButtonFlags : 0);
3360 x -= FRAME_BUTTON_WIDTH;
3361 }
3362 if ( flags & wxTOPLEVEL_BUTTON_HELP )
3363 {
3364 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
3365 (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
3366 specialButtonFlags : 0);
3367 x -= FRAME_BUTTON_WIDTH;
3368 }
3369 }
3370 }
3371
3372 void wxWin32Renderer::DrawFrameBorder(wxDC& dc,
3373 const wxRect& rect,
3374 int flags)
3375 {
3376 if ( !(flags & wxTOPLEVEL_BORDER) ) return;
3377
3378 wxRect r(rect);
3379
3380 DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
3381 DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
3382 DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
3383 if ( flags & wxTOPLEVEL_RESIZEABLE )
3384 DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
3385 }
3386
3387 void wxWin32Renderer::DrawFrameBackground(wxDC& dc,
3388 const wxRect& rect,
3389 int flags)
3390 {
3391 if ( !(flags & wxTOPLEVEL_TITLEBAR) ) return;
3392
3393 wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
3394 wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE) :
3395 wxSCHEME_COLOUR(m_scheme, TITLEBAR);
3396
3397 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3398 r.height = FRAME_TITLEBAR_HEIGHT;
3399
3400 DrawBackground(dc, col, r);
3401 }
3402
3403 void wxWin32Renderer::DrawFrameTitle(wxDC& dc,
3404 const wxRect& rect,
3405 const wxString& title,
3406 int flags)
3407 {
3408 wxColour col = (flags & wxTOPLEVEL_ACTIVE) ?
3409 wxSCHEME_COLOUR(m_scheme, TITLEBAR_ACTIVE_TEXT) :
3410 wxSCHEME_COLOUR(m_scheme, TITLEBAR_TEXT);
3411
3412 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3413 r.height = FRAME_TITLEBAR_HEIGHT;
3414 if ( flags & wxTOPLEVEL_ICON )
3415 r.x += FRAME_TITLEBAR_HEIGHT;
3416 else
3417 r.x += 1;
3418
3419 dc.SetFont(m_titlebarFont);
3420 dc.SetTextForeground(col);
3421 dc.DrawLabel(title, wxNullBitmap, r, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
3422 }
3423
3424 void wxWin32Renderer::DrawFrameIcon(wxDC& dc,
3425 const wxRect& rect,
3426 const wxIcon& icon,
3427 int flags)
3428 {
3429 if ( icon.Ok() )
3430 {
3431 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
3432 dc.DrawIcon(icon, r.x, r.y);
3433 }
3434 }
3435
3436 void wxWin32Renderer::DrawFrameButton(wxDC& dc,
3437 wxCoord x, wxCoord y,
3438 int button,
3439 int flags)
3440 {
3441 wxRect r(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
3442
3443 size_t idx = 0;
3444 switch (button)
3445 {
3446 case wxTOPLEVEL_BUTTON_CLOSE: idx = FrameButton_Close; break;
3447 case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
3448 case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
3449 case wxTOPLEVEL_BUTTON_RESTORE: idx = FrameButton_Restore; break;
3450 case wxTOPLEVEL_BUTTON_HELP: idx = FrameButton_Help; break;
3451 default:
3452 wxFAIL_MSG(wxT("incorrect button specification"));
3453 }
3454
3455 if ( flags & wxCONTROL_PRESSED )
3456 {
3457 DrawShadedRect(dc, &r, m_penBlack, m_penHighlight);
3458 DrawShadedRect(dc, &r, m_penDarkGrey, m_penLightGrey);
3459 DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
3460 dc.DrawBitmap(m_bmpFrameButtons[idx], r.x+1, r.y+1, TRUE);
3461 }
3462 else
3463 {
3464 DrawShadedRect(dc, &r, m_penHighlight, m_penBlack);
3465 DrawShadedRect(dc, &r, m_penLightGrey, m_penDarkGrey);
3466 DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), r);
3467 dc.DrawBitmap(m_bmpFrameButtons[idx], r.x, r.y, TRUE);
3468 }
3469 }
3470
3471
3472 wxRect wxWin32Renderer::GetFrameClientArea(const wxRect& rect,
3473 int flags) const
3474 {
3475 wxRect r(rect);
3476
3477 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3478 {
3479 int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
3480 RESIZEABLE_FRAME_BORDER_THICKNESS :
3481 FRAME_BORDER_THICKNESS;
3482 r.Inflate(-border);
3483 }
3484 if ( flags & wxTOPLEVEL_TITLEBAR )
3485 {
3486 r.y += FRAME_TITLEBAR_HEIGHT;
3487 r.height -= FRAME_TITLEBAR_HEIGHT;
3488 }
3489
3490 return r;
3491 }
3492
3493 wxSize wxWin32Renderer::GetFrameTotalSize(const wxSize& clientSize,
3494 int flags) const
3495 {
3496 wxSize s(clientSize);
3497
3498 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
3499 {
3500 int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
3501 RESIZEABLE_FRAME_BORDER_THICKNESS :
3502 FRAME_BORDER_THICKNESS;
3503 s.x += 2*border;
3504 s.y += 2*border;
3505 }
3506 if ( flags & wxTOPLEVEL_TITLEBAR )
3507 s.y += FRAME_TITLEBAR_HEIGHT;
3508
3509 return s;
3510 }
3511
3512 wxSize wxWin32Renderer::GetFrameIconSize() const
3513 {
3514 return wxSize(16, 16);
3515 }
3516
3517
3518 // ----------------------------------------------------------------------------
3519 // standard icons
3520 // ----------------------------------------------------------------------------
3521
3522 static char *error_xpm[]={
3523 "32 32 5 1",
3524 ". c None",
3525 "# c #800000",
3526 "b c #808080",
3527 "a c #ff0000",
3528 "c c #ffffff",
3529 "...........########.............",
3530 "........###aaaaaaaa###..........",
3531 ".......#aaaaaaaaaaaaaa#.........",
3532 ".....##aaaaaaaaaaaaaaaa##.......",
3533 "....#aaaaaaaaaaaaaaaaaaaa#......",
3534 "...#aaaaaaaaaaaaaaaaaaaaaa#.....",
3535 "...#aaaaaaaaaaaaaaaaaaaaaa#b....",
3536 "..#aaaaaacaaaaaaaaaacaaaaaa#b...",
3537 ".#aaaaaacccaaaaaaaacccaaaaaa#...",
3538 ".#aaaaacccccaaaaaacccccaaaaa#b..",
3539 ".#aaaaaacccccaaaacccccaaaaaa#bb.",
3540 "#aaaaaaaacccccaacccccaaaaaaaa#b.",
3541 "#aaaaaaaaaccccccccccaaaaaaaaa#b.",
3542 "#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
3543 "#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
3544 "#aaaaaaaaaaaccccccaaaaaaaaaaa#bb",
3545 "#aaaaaaaaaaccccccccaaaaaaaaaa#bb",
3546 "#aaaaaaaaaccccccccccaaaaaaaaa#bb",
3547 "#aaaaaaaacccccaacccccaaaaaaaa#bb",
3548 ".#aaaaaacccccaaaacccccaaaaaa#bbb",
3549 ".#aaaaacccccaaaaaacccccaaaaa#bbb",
3550 ".#aaaaaacccaaaaaaaacccaaaaaa#bb.",
3551 "..#aaaaaacaaaaaaaaaacaaaaaa#bbb.",
3552 "...#aaaaaaaaaaaaaaaaaaaaaa#bbbb.",
3553 "...#aaaaaaaaaaaaaaaaaaaaaa#bbb..",
3554 "....#aaaaaaaaaaaaaaaaaaaa#bbb...",
3555 ".....##aaaaaaaaaaaaaaaa##bbbb...",
3556 "......b#aaaaaaaaaaaaaa#bbbbb....",
3557 ".......b###aaaaaaaa###bbbbb.....",
3558 ".........bb########bbbbbb.......",
3559 "..........bbbbbbbbbbbbbb........",
3560 ".............bbbbbbbb..........."};
3561
3562 static char *info_xpm[]={
3563 "32 32 6 1",
3564 ". c None",
3565 "d c #000000",
3566 "c c #0000ff",
3567 "# c #808080",
3568 "a c #c0c0c0",
3569 "b c #ffffff",
3570 "...........########.............",
3571 "........###abbbbbba###..........",
3572 "......##abbbbbbbbbbbba##........",
3573 ".....#abbbbbbbbbbbbbbbba#.......",
3574 "....#bbbbbbbaccccabbbbbbbd......",
3575 "...#bbbbbbbbccccccbbbbbbbbd.....",
3576 "..#bbbbbbbbbccccccbbbbbbbbbd....",
3577 ".#abbbbbbbbbaccccabbbbbbbbbad...",
3578 ".#bbbbbbbbbbbbbbbbbbbbbbbbbbd#..",
3579 "#abbbbbbbbbbbbbbbbbbbbbbbbbbad#.",
3580 "#bbbbbbbbbbcccccccbbbbbbbbbbbd#.",
3581 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3582 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3583 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3584 "#bbbbbbbbbbbbcccccbbbbbbbbbbbd##",
3585 "#abbbbbbbbbbbcccccbbbbbbbbbbad##",
3586 ".#bbbbbbbbbbbcccccbbbbbbbbbbd###",
3587 ".#abbbbbbbbbbcccccbbbbbbbbbad###",
3588 "..#bbbbbbbbcccccccccbbbbbbbd###.",
3589 "...dbbbbbbbbbbbbbbbbbbbbbbd####.",
3590 "....dbbbbbbbbbbbbbbbbbbbbd####..",
3591 ".....dabbbbbbbbbbbbbbbbad####...",
3592 "......ddabbbbbbbbbbbbadd####....",
3593 ".......#dddabbbbbbaddd#####.....",
3594 "........###dddabbbd#######......",
3595 "..........####dbbbd#####........",
3596 ".............#dbbbd##...........",
3597 "...............dbbd##...........",
3598 "................dbd##...........",
3599 ".................dd##...........",
3600 "..................###...........",
3601 "...................##..........."};
3602
3603 static char *question_xpm[]={
3604 "32 32 6 1",
3605 ". c None",
3606 "c c #000000",
3607 "d c #0000ff",
3608 "# c #808080",
3609 "a c #c0c0c0",
3610 "b c #ffffff",
3611 "...........########.............",
3612 "........###abbbbbba###..........",
3613 "......##abbbbbbbbbbbba##........",
3614 ".....#abbbbbbbbbbbbbbbba#.......",
3615 "....#bbbbbbbbbbbbbbbbbbbbc......",
3616 "...#bbbbbbbaddddddabbbbbbbc.....",
3617 "..#bbbbbbbadabbddddabbbbbbbc....",
3618 ".#abbbbbbbddbbbbddddbbbbbbbac...",
3619 ".#bbbbbbbbddddbbddddbbbbbbbbc#..",
3620 "#abbbbbbbbddddbaddddbbbbbbbbac#.",
3621 "#bbbbbbbbbaddabddddbbbbbbbbbbc#.",
3622 "#bbbbbbbbbbbbbadddbbbbbbbbbbbc##",
3623 "#bbbbbbbbbbbbbdddbbbbbbbbbbbbc##",
3624 "#bbbbbbbbbbbbbddabbbbbbbbbbbbc##",
3625 "#bbbbbbbbbbbbbddbbbbbbbbbbbbbc##",
3626 "#abbbbbbbbbbbbbbbbbbbbbbbbbbac##",
3627 ".#bbbbbbbbbbbaddabbbbbbbbbbbc###",
3628 ".#abbbbbbbbbbddddbbbbbbbbbbac###",
3629 "..#bbbbbbbbbbddddbbbbbbbbbbc###.",
3630 "...cbbbbbbbbbaddabbbbbbbbbc####.",
3631 "....cbbbbbbbbbbbbbbbbbbbbc####..",
3632 ".....cabbbbbbbbbbbbbbbbac####...",
3633 "......ccabbbbbbbbbbbbacc####....",
3634 ".......#cccabbbbbbaccc#####.....",
3635 "........###cccabbbc#######......",
3636 "..........####cbbbc#####........",
3637 ".............#cbbbc##...........",
3638 "...............cbbc##...........",
3639 "................cbc##...........",
3640 ".................cc##...........",
3641 "..................###...........",
3642 "...................##..........."};
3643
3644 static char *warning_xpm[]={
3645 "32 32 6 1",
3646 ". c None",
3647 "c c #000000",
3648 "# c #808000",
3649 "d c #808080",
3650 "b c #c0c0c0",
3651 "a c #ffff00",
3652 ".............###................",
3653 "............#aabc...............",
3654 "...........#aaaabcd.............",
3655 "...........#aaaaacdd............",
3656 "..........#aaaaaabcdd...........",
3657 "..........#aaaaaaacdd...........",
3658 ".........#aaaaaaaabcdd..........",
3659 ".........#aaaaaaaaacdd..........",
3660 "........#aaaaaaaaaabcdd.........",
3661 "........#aaabcccbaaacdd.........",
3662 ".......#aaaacccccaaabcdd........",
3663 ".......#aaaacccccaaaacdd........",
3664 "......#aaaaacccccaaaabcdd.......",
3665 "......#aaaaacccccaaaaacdd.......",
3666 ".....#aaaaaacccccaaaaabcdd......",
3667 ".....#aaaaaa#ccc#aaaaaacdd......",
3668 "....#aaaaaaabcccbaaaaaabcdd.....",
3669 "....#aaaaaaaacccaaaaaaaacdd.....",
3670 "...#aaaaaaaaa#c#aaaaaaaabcdd....",
3671 "...#aaaaaaaaabcbaaaaaaaaacdd....",
3672 "..#aaaaaaaaaaacaaaaaaaaaabcdd...",
3673 "..#aaaaaaaaaaaaaaaaaaaaaaacdd...",
3674 ".#aaaaaaaaaaabccbaaaaaaaaabcdd..",
3675 ".#aaaaaaaaaaaccccaaaaaaaaaacdd..",
3676 "#aaaaaaaaaaaaccccaaaaaaaaaabcdd.",
3677 "#aaaaaaaaaaaabccbaaaaaaaaaaacdd.",
3678 "#aaaaaaaaaaaaaaaaaaaaaaaaaaacddd",
3679 "#aaaaaaaaaaaaaaaaaaaaaaaaaabcddd",
3680 ".#aaaaaaaaaaaaaaaaaaaaaaaabcdddd",
3681 "..#ccccccccccccccccccccccccddddd",
3682 "....ddddddddddddddddddddddddddd.",
3683 ".....ddddddddddddddddddddddddd.."};
3684
3685 wxIcon wxWin32Renderer::GetStdIcon(int which) const
3686 {
3687 switch(which)
3688 {
3689 case wxICON_INFORMATION:
3690 return wxIcon(info_xpm);
3691
3692 case wxICON_QUESTION:
3693 return wxIcon(question_xpm);
3694
3695 case wxICON_EXCLAMATION:
3696 return wxIcon(warning_xpm);
3697
3698 default:
3699 wxFAIL_MSG(wxT("requested non existent standard icon"));
3700 // still fall through
3701
3702 case wxICON_HAND:
3703 return wxIcon(error_xpm);
3704 }
3705 }
3706
3707
3708 // ----------------------------------------------------------------------------
3709 // text control geometry
3710 // ----------------------------------------------------------------------------
3711
3712 static inline int GetTextBorderWidth()
3713 {
3714 return 1;
3715 }
3716
3717 wxRect wxWin32Renderer::GetTextTotalArea(const wxTextCtrl *text,
3718 const wxRect& rect)
3719 {
3720 wxRect rectTotal = rect;
3721
3722 wxCoord widthBorder = GetTextBorderWidth();
3723 rectTotal.Inflate(widthBorder);
3724
3725 // this is what Windows does
3726 rectTotal.height++;
3727
3728 return rectTotal;
3729 }
3730
3731 wxRect wxWin32Renderer::GetTextClientArea(const wxTextCtrl *text,
3732 const wxRect& rect,
3733 wxCoord *extraSpaceBeyond)
3734 {
3735 wxRect rectText = rect;
3736
3737 // undo GetTextTotalArea()
3738 if ( rectText.height > 0 )
3739 rectText.height--;
3740
3741 wxCoord widthBorder = GetTextBorderWidth();
3742 rectText.Inflate(-widthBorder);
3743
3744 if ( extraSpaceBeyond )
3745 *extraSpaceBeyond = 0;
3746
3747 return rectText;
3748 }
3749
3750 // ----------------------------------------------------------------------------
3751 // size adjustments
3752 // ----------------------------------------------------------------------------
3753
3754 void wxWin32Renderer::AdjustSize(wxSize *size, const wxWindow *window)
3755 {
3756 #if wxUSE_SCROLLBAR
3757 if ( wxDynamicCast(window, wxScrollBar) )
3758 {
3759 // we only set the width of vert scrollbars and height of the
3760 // horizontal ones
3761 if ( window->GetWindowStyle() & wxSB_HORIZONTAL )
3762 size->y = m_sizeScrollbarArrow.y;
3763 else
3764 size->x = m_sizeScrollbarArrow.x;
3765
3766 // skip border width adjustments, they don't make sense for us
3767 return;
3768 }
3769 #endif // wxUSE_SCROLLBAR/!wxUSE_SCROLLBAR
3770
3771 #if wxUSE_BUTTON
3772 if ( wxDynamicCast(window, wxButton) )
3773 {
3774 if ( !(window->GetWindowStyle() & wxBU_EXACTFIT) )
3775 {
3776 // TODO: don't harcode all this
3777 size->x += 3*window->GetCharWidth();
3778
3779 wxCoord heightBtn = (11*(window->GetCharHeight() + 8))/10;
3780 if ( size->y < heightBtn - 8 )
3781 size->y = heightBtn;
3782 else
3783 size->y += 9;
3784 }
3785
3786 // no border width adjustments for buttons
3787 return;
3788 }
3789 #endif // wxUSE_BUTTON
3790
3791 // take into account the border width
3792 wxRect rectBorder = GetBorderDimensions(window->GetBorder());
3793 size->x += rectBorder.x + rectBorder.width;
3794 size->y += rectBorder.y + rectBorder.height;
3795 }
3796
3797 // ============================================================================
3798 // wxInputHandler
3799 // ============================================================================
3800
3801 // ----------------------------------------------------------------------------
3802 // wxWin32InputHandler
3803 // ----------------------------------------------------------------------------
3804
3805 wxWin32InputHandler::wxWin32InputHandler(wxWin32Renderer *renderer)
3806 {
3807 m_renderer = renderer;
3808 }
3809
3810 bool wxWin32InputHandler::HandleKey(wxInputConsumer *control,
3811 const wxKeyEvent& event,
3812 bool pressed)
3813 {
3814 return FALSE;
3815 }
3816
3817 bool wxWin32InputHandler::HandleMouse(wxInputConsumer *control,
3818 const wxMouseEvent& event)
3819 {
3820 // clicking on the control gives it focus
3821 if ( event.ButtonDown() )
3822 {
3823 wxWindow *win = control->GetInputWindow();
3824 if ( wxWindow::FindFocus() != control->GetInputWindow() )
3825 {
3826 win->SetFocus();
3827
3828 return TRUE;
3829 }
3830 }
3831
3832 return FALSE;
3833 }
3834
3835 // ----------------------------------------------------------------------------
3836 // wxWin32ScrollBarInputHandler
3837 // ----------------------------------------------------------------------------
3838
3839 wxWin32ScrollBarInputHandler::
3840 wxWin32ScrollBarInputHandler(wxWin32Renderer *renderer,
3841 wxInputHandler *handler)
3842 : wxStdScrollBarInputHandler(renderer, handler)
3843 {
3844 m_scrollPaused = FALSE;
3845 m_interval = 0;
3846 }
3847
3848 bool wxWin32ScrollBarInputHandler::OnScrollTimer(wxScrollBar *scrollbar,
3849 const wxControlAction& action)
3850 {
3851 // stop if went beyond the position of the original click (this can only
3852 // happen when we scroll by pages)
3853 bool stop = FALSE;
3854 if ( action == wxACTION_SCROLL_PAGE_DOWN )
3855 {
3856 stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
3857 != wxHT_SCROLLBAR_BAR_2;
3858 }
3859 else if ( action == wxACTION_SCROLL_PAGE_UP )
3860 {
3861 stop = m_renderer->HitTestScrollbar(scrollbar, m_ptStartScrolling)
3862 != wxHT_SCROLLBAR_BAR_1;
3863 }
3864
3865 if ( stop )
3866 {
3867 StopScrolling(scrollbar);
3868
3869 scrollbar->Refresh();
3870
3871 return FALSE;
3872 }
3873
3874 return wxStdScrollBarInputHandler::OnScrollTimer(scrollbar, action);
3875 }
3876
3877 bool wxWin32ScrollBarInputHandler::HandleMouse(wxInputConsumer *control,
3878 const wxMouseEvent& event)
3879 {
3880 // remember the current state
3881 bool wasDraggingThumb = m_htLast == wxHT_SCROLLBAR_THUMB;
3882
3883 // do process the message
3884 bool rc = wxStdScrollBarInputHandler::HandleMouse(control, event);
3885
3886 // analyse the changes
3887 if ( !wasDraggingThumb && (m_htLast == wxHT_SCROLLBAR_THUMB) )
3888 {
3889 // we just started dragging the thumb, remember its initial position to
3890 // be able to restore it if the drag is cancelled later
3891 m_eventStartDrag = event;
3892 }
3893
3894 return rc;
3895 }
3896
3897 bool wxWin32ScrollBarInputHandler::HandleMouseMove(wxInputConsumer *control,
3898 const wxMouseEvent& event)
3899 {
3900 // we don't highlight scrollbar elements, so there is no need to process
3901 // mouse move events normally - only do it while mouse is captured (i.e.
3902 // when we're dragging the thumb or pressing on something)
3903 if ( !m_winCapture )
3904 return FALSE;
3905
3906 if ( event.Entering() )
3907 {
3908 // we're not interested in this at all
3909 return FALSE;
3910 }
3911
3912 wxScrollBar *scrollbar = wxStaticCast(control->GetInputWindow(), wxScrollBar);
3913 wxHitTest ht;
3914 if ( m_scrollPaused )
3915 {
3916 // check if the mouse returned to its original location
3917
3918 if ( event.Leaving() )
3919 {
3920 // it surely didn't
3921 return FALSE;
3922 }
3923
3924 ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
3925 if ( ht == m_htLast )
3926 {
3927 // yes it did, resume scrolling
3928 m_scrollPaused = FALSE;
3929 if ( m_timerScroll )
3930 {
3931 // we were scrolling by line/page, restart timer
3932 m_timerScroll->Start(m_interval);
3933
3934 Press(scrollbar, TRUE);
3935 }
3936 else // we were dragging the thumb
3937 {
3938 // restore its last location
3939 HandleThumbMove(scrollbar, m_eventLastDrag);
3940 }
3941
3942 return TRUE;
3943 }
3944 }
3945 else // normal case, scrolling hasn't been paused
3946 {
3947 // if we're scrolling the scrollbar because the arrow or the shaft was
3948 // pressed, check that the mouse stays on the same scrollbar element
3949
3950 if ( event.Moving() )
3951 {
3952 ht = m_renderer->HitTestScrollbar(scrollbar, event.GetPosition());
3953 }
3954 else // event.Leaving()
3955 {
3956 ht = wxHT_NOWHERE;
3957 }
3958
3959 // if we're dragging the thumb and the mouse stays in the scrollbar, it
3960 // is still ok - we only want to catch the case when the mouse leaves
3961 // the scrollbar here
3962 if ( m_htLast == wxHT_SCROLLBAR_THUMB && ht != wxHT_NOWHERE )
3963 {
3964 ht = wxHT_SCROLLBAR_THUMB;
3965 }
3966
3967 if ( ht != m_htLast )
3968 {
3969 // what were we doing? 2 possibilities: either an arrow/shaft was
3970 // pressed in which case we have a timer and so we just stop it or
3971 // we were dragging the thumb
3972 if ( m_timerScroll )
3973 {
3974 // pause scrolling
3975 m_interval = m_timerScroll->GetInterval();
3976 m_timerScroll->Stop();
3977 m_scrollPaused = TRUE;
3978
3979 // unpress the arrow
3980 Press(scrollbar, FALSE);
3981 }
3982 else // we were dragging the thumb
3983 {
3984 // remember the current thumb position to be able to restore it
3985 // if the mouse returns to it later
3986 m_eventLastDrag = event;
3987
3988 // and restore the original position (before dragging) of the
3989 // thumb for now
3990 HandleThumbMove(scrollbar, m_eventStartDrag);
3991 }
3992
3993 return TRUE;
3994 }
3995 }
3996
3997 return wxStdScrollBarInputHandler::HandleMouseMove(control, event);
3998 }
3999
4000 // ----------------------------------------------------------------------------
4001 // wxWin32CheckboxInputHandler
4002 // ----------------------------------------------------------------------------
4003
4004 bool wxWin32CheckboxInputHandler::HandleKey(wxInputConsumer *control,
4005 const wxKeyEvent& event,
4006 bool pressed)
4007 {
4008 if ( pressed )
4009 {
4010 wxControlAction action;
4011 int keycode = event.GetKeyCode();
4012 switch ( keycode )
4013 {
4014 case WXK_SPACE:
4015 action = wxACTION_CHECKBOX_TOGGLE;
4016 break;
4017
4018 case WXK_SUBTRACT:
4019 case WXK_NUMPAD_SUBTRACT:
4020 action = wxACTION_CHECKBOX_CHECK;
4021 break;
4022
4023 case WXK_ADD:
4024 case WXK_NUMPAD_ADD:
4025 case WXK_NUMPAD_EQUAL:
4026 action = wxACTION_CHECKBOX_CLEAR;
4027 break;
4028 }
4029
4030 if ( !!action )
4031 {
4032 control->PerformAction(action);
4033
4034 return TRUE;
4035 }
4036 }
4037
4038 return FALSE;
4039 }
4040
4041 // ----------------------------------------------------------------------------
4042 // wxWin32TextCtrlInputHandler
4043 // ----------------------------------------------------------------------------
4044
4045 bool wxWin32TextCtrlInputHandler::HandleKey(wxInputConsumer *control,
4046 const wxKeyEvent& event,
4047 bool pressed)
4048 {
4049 // handle only MSW-specific text bindings here, the others are handled in
4050 // the base class
4051 if ( pressed )
4052 {
4053 int keycode = event.GetKeyCode();
4054
4055 wxControlAction action;
4056 if ( keycode == WXK_DELETE && event.ShiftDown() )
4057 {
4058 action = wxACTION_TEXT_CUT;
4059 }
4060 else if ( keycode == WXK_INSERT )
4061 {
4062 if ( event.ControlDown() )
4063 action = wxACTION_TEXT_COPY;
4064 else if ( event.ShiftDown() )
4065 action = wxACTION_TEXT_PASTE;
4066 }
4067
4068 if ( action != wxACTION_NONE )
4069 {
4070 control->PerformAction(action);
4071
4072 return TRUE;
4073 }
4074 }
4075
4076 return wxStdTextCtrlInputHandler::HandleKey(control, event, pressed);
4077 }
4078
4079 // ----------------------------------------------------------------------------
4080 // wxWin32StatusBarInputHandler
4081 // ----------------------------------------------------------------------------
4082
4083 wxWin32StatusBarInputHandler::
4084 wxWin32StatusBarInputHandler(wxInputHandler *handler)
4085 : wxStdInputHandler(handler)
4086 {
4087 m_isOnGrip = FALSE;
4088 }
4089
4090 bool wxWin32StatusBarInputHandler::IsOnGrip(wxWindow *statbar,
4091 const wxPoint& pt) const
4092 {
4093 if ( statbar->HasFlag(wxST_SIZEGRIP) &&
4094 statbar->GetParent()->HasFlag(wxRESIZE_BORDER) )
4095 {
4096 wxSize sizeSbar = statbar->GetSize();
4097
4098 return (sizeSbar.x - pt.x) < (wxCoord)STATUSBAR_GRIP_SIZE &&
4099 (sizeSbar.y - pt.y) < (wxCoord)STATUSBAR_GRIP_SIZE;
4100 }
4101
4102 return FALSE;
4103 }
4104
4105 bool wxWin32StatusBarInputHandler::HandleMouse(wxInputConsumer *consumer,
4106 const wxMouseEvent& event)
4107 {
4108 if ( event.Button(1) )
4109 {
4110 if ( event.ButtonDown(1) )
4111 {
4112 wxWindow *statbar = consumer->GetInputWindow();
4113
4114 if ( IsOnGrip(statbar, event.GetPosition()) )
4115 {
4116 wxTopLevelWindow *tlw = wxDynamicCast(statbar->GetParent(),
4117 wxTopLevelWindow);
4118 if ( tlw )
4119 {
4120 tlw->PerformAction(wxACTION_TOPLEVEL_RESIZE,
4121 wxHT_TOPLEVEL_BORDER_SE);
4122
4123 statbar->SetCursor(m_cursorOld);
4124
4125 return TRUE;
4126 }
4127 }
4128 }
4129 }
4130
4131 return wxStdInputHandler::HandleMouse(consumer, event);
4132 }
4133
4134 bool wxWin32StatusBarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
4135 const wxMouseEvent& event)
4136 {
4137 wxWindow *statbar = consumer->GetInputWindow();
4138
4139 bool isOnGrip = IsOnGrip(statbar, event.GetPosition());
4140 if ( isOnGrip != m_isOnGrip )
4141 {
4142 m_isOnGrip = isOnGrip;
4143 if ( isOnGrip )
4144 {
4145 m_cursorOld = statbar->GetCursor();
4146 statbar->SetCursor(wxCURSOR_SIZENWSE);
4147 }
4148 else
4149 {
4150 statbar->SetCursor(m_cursorOld);
4151 }
4152 }
4153
4154 return wxStdInputHandler::HandleMouseMove(consumer, event);
4155 }
4156
wxWidgets (Impactor)