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