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