1 ///////////////////////////////////////////////////////////////////////////////
2 // Name:        wx/univ/renderer.h
3 // Purpose:     wxRenderer class declaration
4 // Author:      Vadim Zeitlin
5 // Modified by:
6 // Created:     06.08.00
7 // RCS-ID:      $Id: renderer.h,v 1.1 2006/12/02 15:58:58 scara Exp $
8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence:     wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11 
12 /*
13    wxRenderer class is used to draw all wxWindows controls. This is an ABC and
14    the look of the application is determined by the concrete derivation of
15    wxRenderer used in the program.
16 
17    It also contains a few static methods which may be used by the concrete
18    renderers and provide the functionality which is often similar or identical
19    in all renderers (using inheritance here would be more restrictive as the
20    given concrete renderer may need an arbitrary subset of the base class
21    methods)
22  */
23 
24 #ifdef __GNUG__
25     #pragma interface "renderer.h"
26 #endif
27 
28 #ifndef _WX_UNIV_RENDERER_H_
29 #define _WX_UNIV_RENDERER_H_
30 
31 class WXDLLEXPORT wxDC;
32 class WXDLLEXPORT wxCheckListBox;
33 class WXDLLEXPORT wxListBox;
34 class WXDLLEXPORT wxMenu;
35 class WXDLLEXPORT wxMenuGeometryInfo;
36 class WXDLLEXPORT wxScrollBar;
37 class WXDLLEXPORT wxTextCtrl;
38 class WXDLLEXPORT wxWindow;
39 #if wxUSE_GAUGE
40 class WXDLLEXPORT wxGauge;
41 #endif // wxUSE_GAUGE
42 
43 #include "wx/string.h"
44 #include "wx/gdicmn.h"
45 #include "wx/icon.h"
46 #include "wx/scrolbar.h"            // for wxScrollBar::Element
47 
48 // helper class used by wxMenu-related functions
49 class WXDLLEXPORT wxMenuGeometryInfo
50 {
51 public:
52     // get the total size of the menu
53     virtual wxSize GetSize() const = 0;
54 
55     virtual ~wxMenuGeometryInfo();
56 };
57 
58 // ----------------------------------------------------------------------------
59 // wxRenderer: abstract renderers interface
60 // ----------------------------------------------------------------------------
61 
62 class WXDLLEXPORT wxRenderer
63 {
64 public:
65     // drawing functions
66     // -----------------
67 
68     // draw the controls background
69     virtual void DrawBackground(wxDC& dc,
70                                 const wxColour& col,
71                                 const wxRect& rect,
72                                 int flags,
73                                 wxWindow *window = NULL ) = 0;
74 
75     // draw the button surface
DrawButtonSurface(wxDC & dc,const wxColour & col,const wxRect & rect,int flags)76     virtual void DrawButtonSurface(wxDC& dc,
77                                 const wxColour& col,
78                                 const wxRect& rect,
79                                 int flags )
80         { DrawBackground( dc, col, rect, flags ); }
81 
82 
83     // draw the label inside the given rectangle with the specified alignment
84     // and optionally emphasize the character with the given index
85     virtual void DrawLabel(wxDC& dc,
86                            const wxString& label,
87                            const wxRect& rect,
88                            int flags = 0,
89                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
90                            int indexAccel = -1,
91                            wxRect *rectBounds = NULL) = 0;
92 
93     // same but also draw a bitmap if it is valid
94     virtual void DrawButtonLabel(wxDC& dc,
95                                  const wxString& label,
96                                  const wxBitmap& image,
97                                  const wxRect& rect,
98                                  int flags = 0,
99                                  int alignment = wxALIGN_LEFT | wxALIGN_TOP,
100                                  int indexAccel = -1,
101                                  wxRect *rectBounds = NULL) = 0;
102 
103     // draw the border and optionally return the rectangle containing the
104     // region inside the border
105     virtual void DrawBorder(wxDC& dc,
106                             wxBorder border,
107                             const wxRect& rect,
108                             int flags = 0,
109                             wxRect *rectIn = (wxRect *)NULL) = 0;
110 
111     // draw text control border (I hate to have a separate method for this but
112     // it is needed to accomodate GTK+)
113     virtual void DrawTextBorder(wxDC& dc,
114                                 wxBorder border,
115                                 const wxRect& rect,
116                                 int flags = 0,
117                                 wxRect *rectIn = (wxRect *)NULL) = 0;
118 
119     // draw push button border and return the rectangle left for the label
120     virtual void DrawButtonBorder(wxDC& dc,
121                                   const wxRect& rect,
122                                   int flags = 0,
123                                   wxRect *rectIn = (wxRect *)NULL) = 0;
124 
125     // draw a horizontal line
126     virtual void DrawHorizontalLine(wxDC& dc,
127                                     wxCoord y, wxCoord x1, wxCoord x2) = 0;
128 
129     // draw a vertical line
130     virtual void DrawVerticalLine(wxDC& dc,
131                                   wxCoord x, wxCoord y1, wxCoord y2) = 0;
132 
133     // draw a frame with the label (horizontal alignment can be specified)
134     virtual void DrawFrame(wxDC& dc,
135                            const wxString& label,
136                            const wxRect& rect,
137                            int flags = 0,
138                            int alignment = wxALIGN_LEFT,
139                            int indexAccel = -1) = 0;
140 
141     // draw an arrow in the given direction
142     virtual void DrawArrow(wxDC& dc,
143                            wxDirection dir,
144                            const wxRect& rect,
145                            int flags = 0) = 0;
146 
147     // draw a scrollbar arrow (may be the same as arrow but may be not)
148     virtual void DrawScrollbarArrow(wxDC& dc,
149                                     wxDirection dir,
150                                     const wxRect& rect,
151                                     int flags = 0) = 0;
152 
153     // draw the scrollbar thumb
154     virtual void DrawScrollbarThumb(wxDC& dc,
155                                     wxOrientation orient,
156                                     const wxRect& rect,
157                                     int flags = 0) = 0;
158 
159     // draw a (part of) scrollbar shaft
160     virtual void DrawScrollbarShaft(wxDC& dc,
161                                     wxOrientation orient,
162                                     const wxRect& rect,
163                                     int flags = 0) = 0;
164 
165     // draw the rectangle in the corner between two scrollbars
166     virtual void DrawScrollCorner(wxDC& dc,
167                                   const wxRect& rect) = 0;
168 
169     // draw an item of a wxListBox
170     virtual void DrawItem(wxDC& dc,
171                           const wxString& label,
172                           const wxRect& rect,
173                           int flags = 0) = 0;
174 
175     // draw an item of a wxCheckListBox
176     virtual void DrawCheckItem(wxDC& dc,
177                                const wxString& label,
178                                const wxBitmap& bitmap,
179                                const wxRect& rect,
180                                int flags = 0) = 0;
181 
182     // draw a checkbutton (bitmap may be invalid to use default one)
183     virtual void DrawCheckButton(wxDC& dc,
184                                  const wxString& label,
185                                  const wxBitmap& bitmap,
186                                  const wxRect& rect,
187                                  int flags = 0,
188                                  wxAlignment align = wxALIGN_LEFT,
189                                  int indexAccel = -1) = 0;
190 
191     // draw a radio button
192     virtual void DrawRadioButton(wxDC& dc,
193                                  const wxString& label,
194                                  const wxBitmap& bitmap,
195                                  const wxRect& rect,
196                                  int flags = 0,
197                                  wxAlignment align = wxALIGN_LEFT,
198                                  int indexAccel = -1) = 0;
199 
200     // draw a toolbar button (label may be empty, bitmap may be invalid, if
201     // both conditions are true this function draws a separator)
202     virtual void DrawToolBarButton(wxDC& dc,
203                                    const wxString& label,
204                                    const wxBitmap& bitmap,
205                                    const wxRect& rect,
206                                    int flags = 0) = 0;
207 
208     // draw a (part of) line in the text control
209     virtual void DrawTextLine(wxDC& dc,
210                               const wxString& text,
211                               const wxRect& rect,
212                               int selStart = -1,
213                               int selEnd = -1,
214                               int flags = 0) = 0;
215 
216     // draw a line wrap indicator
217     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) = 0;
218 
219     // draw a notebook tab
220     virtual void DrawTab(wxDC& dc,
221                          const wxRect& rect,
222                          wxDirection dir,
223                          const wxString& label,
224                          const wxBitmap& bitmap = wxNullBitmap,
225                          int flags = 0,
226                          int indexAccel = -1) = 0;
227 
228     // draw the slider shaft
229     virtual void DrawSliderShaft(wxDC& dc,
230                                  const wxRect& rect,
231                                  wxOrientation orient,
232                                  int flags = 0,
233                                  wxRect *rectShaft = NULL) = 0;
234 
235     // draw the slider thumb
236     virtual void DrawSliderThumb(wxDC& dc,
237                                  const wxRect& rect,
238                                  wxOrientation orient,
239                                  int flags = 0) = 0;
240 
241     // draw the slider ticks
242     virtual void DrawSliderTicks(wxDC& dc,
243                                  const wxRect& rect,
244                                  const wxSize& sizeThumb,
245                                  wxOrientation orient,
246                                  int start,
247                                  int end,
248                                  int step = 1,
249                                  int flags = 0) = 0;
250 
251     // draw a menu bar item
252     virtual void DrawMenuBarItem(wxDC& dc,
253                                  const wxRect& rect,
254                                  const wxString& label,
255                                  int flags = 0,
256                                  int indexAccel = -1) = 0;
257 
258     // draw a menu item (also used for submenus if flags has ISSUBMENU flag)
259     //
260     // the geometryInfo is calculated by GetMenuGeometry() function from below
261     virtual void DrawMenuItem(wxDC& dc,
262                               wxCoord y,
263                               const wxMenuGeometryInfo& geometryInfo,
264                               const wxString& label,
265                               const wxString& accel,
266                               const wxBitmap& bitmap = wxNullBitmap,
267                               int flags = 0,
268                               int indexAccel = -1) = 0;
269 
270     // draw a menu bar separator
271     virtual void DrawMenuSeparator(wxDC& dc,
272                                    wxCoord y,
273                                    const wxMenuGeometryInfo& geomInfo) = 0;
274 
275     // draw a status bar field: wxCONTROL_ISDEFAULT bit in the flags is
276     // interpreted specially and means "draw the status bar grip" here
277     virtual void DrawStatusField(wxDC& dc,
278                                  const wxRect& rect,
279                                  const wxString& label,
280                                  int flags = 0) = 0;
281 
282     // draw complete frame/dialog titlebar
283     virtual void DrawFrameTitleBar(wxDC& dc,
284                                    const wxRect& rect,
285                                    const wxString& title,
286                                    const wxIcon& icon,
287                                    int flags,
288                                    int specialButton = 0,
289                                    int specialButtonFlags = 0) = 0;
290 
291     // draw frame borders
292     virtual void DrawFrameBorder(wxDC& dc,
293                                  const wxRect& rect,
294                                  int flags) = 0;
295 
296     // draw frame titlebar background
297     virtual void DrawFrameBackground(wxDC& dc,
298                                      const wxRect& rect,
299                                      int flags) = 0;
300 
301     // draw frame title
302     virtual void DrawFrameTitle(wxDC& dc,
303                                 const wxRect& rect,
304                                 const wxString& title,
305                                 int flags) = 0;
306 
307     // draw frame icon
308     virtual void DrawFrameIcon(wxDC& dc,
309                                const wxRect& rect,
310                                const wxIcon& icon,
311                                int flags) = 0;
312 
313     // draw frame buttons
314     virtual void DrawFrameButton(wxDC& dc,
315                                  wxCoord x, wxCoord y,
316                                  int button,
317                                  int flags = 0) = 0;
318 
319     // misc functions
320     // --------------
321 
322     // return the bitmaps to use for combobox button
323     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
324                                  wxBitmap *bmpFocus,
325                                  wxBitmap *bmpPressed,
326                                  wxBitmap *bmpDisabled) = 0;
327 
328     // geometry functions
329     // ------------------
330 
331     // get the dimensions of the border: rect.x/y contain the width/height of
332     // the left/top side, width/heigh - of the right/bottom one
333     virtual wxRect GetBorderDimensions(wxBorder border) const = 0;
334 
335     // the scrollbars may be drawn either inside the window border or outside
336     // it - this function is used to decide how to draw them
337     virtual bool AreScrollbarsInsideBorder() const = 0;
338 
339     // adjust the size of the control of the given class: for most controls,
340     // this just takes into account the border, but for some (buttons, for
341     // example) it is more complicated - the result being, in any case, that
342     // the control looks "nice" if it uses the adjusted rectangle
343     virtual void AdjustSize(wxSize *size, const wxWindow *window) = 0;
344 
345     // get the size of a scrollbar arrow
346     virtual wxSize GetScrollbarArrowSize() const = 0;
347 
348     // gets the bounding box for a scrollbar element for the given (by default
349     // - current) thumb position
350     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
351                                     wxScrollBar::Element elem,
352                                     int thumbPos = -1) const = 0;
353 
354     // returns the size of the scrollbar shaft excluding the arrows
355     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar) = 0;
356 
357     // returns one of wxHT_SCROLLBAR_XXX constants
358     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
359                                        const wxPoint& pt) const = 0;
360 
361     // translate the scrollbar position (in logical units) into physical
362     // coordinate (in pixels) and the other way round
363     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
364                                      int thumbPos = -1) = 0;
365     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
366                                  wxCoord coord) = 0;
367 
368     // get the height of a listbox item from the base font height
369     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) = 0;
370 
371     // get the size of a checkbox/radio button bitmap
372     virtual wxSize GetCheckBitmapSize() const = 0;
373     virtual wxSize GetRadioBitmapSize() const = 0;
374     virtual wxCoord GetCheckItemMargin() const = 0;
375 
376     // get the standard size of a toolbar button and also return the size of
377     // a toolbar separator in the provided pointer
378     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const = 0;
379 
380     // get the margins between/around the toolbar buttons
381     virtual wxSize GetToolBarMargin() const = 0;
382 
383     // convert between text rectangle and client rectangle for text controls:
384     // the former is typicall smaller to leave margins around text
385     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
386                                     const wxRect& rectText) const = 0;
387 
388     // extra space is for line indicators
389     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
390                                      const wxRect& rectTotal,
391                                      wxCoord *extraSpaceBeyond) const = 0;
392 
393     // get the overhang of a selected tab
394     virtual wxSize GetTabIndent() const = 0;
395 
396     // get the padding around the text in a tab
397     virtual wxSize GetTabPadding() const = 0;
398 
399     // get the default size of the slider in lesser dimension (i.e. height of a
400     // horizontal slider or width of a vertical one)
401     virtual wxCoord GetSliderDim() const = 0;
402 
403     // get the length of the slider ticks displayed along side slider
404     virtual wxCoord GetSliderTickLen() const = 0;
405 
406     // get the slider shaft rect from the total slider rect
407     virtual wxRect GetSliderShaftRect(const wxRect& rect,
408                                       wxOrientation orient) const = 0;
409 
410     // get the size of the slider thumb for the given total slider rect
411     virtual wxSize GetSliderThumbSize(const wxRect& rect,
412                                       wxOrientation orient) const = 0;
413 
414     // get the size of one progress bar step (in horz and vertical directions)
415     virtual wxSize GetProgressBarStep() const = 0;
416 
417     // get the size of rectangle to use in the menubar for the given text rect
418     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const = 0;
419 
420     // get the struct storing all layout info needed to draw all menu items
421     // (this can't be calculated for each item separately as they should be
422     // aligned)
423     //
424     // the returned pointer must be deleted by the caller
425     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
426                                                 const wxMenu& menu) const = 0;
427 
428     // get the borders around the status bar fields (x and y fields of the
429     // return value) and also, optionally, the border between the fields
430     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const = 0;
431 
432     // get client area rectangle of top level window (i.e. subtract
433     // decorations from given rectangle)
434     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const = 0;
435 
436     // get size of whole top level window, given size of its client area size
437     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const = 0;
438 
439     // get the minimal size of top level window
440     virtual wxSize GetFrameMinSize(int flags) const = 0;
441 
442     // get titlebar icon size
443     virtual wxSize GetFrameIconSize() const = 0;
444 
445     // returns one of wxHT_TOPLEVEL_XXX constants
446     virtual int HitTestFrame(const wxRect& rect,
447                              const wxPoint& pt,
448                              int flags = 0) const = 0;
449 
450     // virtual dtor for any base class
451     virtual ~wxRenderer();
452 
453 protected:
454     // draw a frame around rectFrame rectangle but not touching the rectLabel
455     // one: this is used by DrawFrame()
456     void StandardDrawFrame(wxDC& dc,
457                            const wxRect& rectFrame,
458                            const wxRect& rectLabel);
459 
460     // standard text line drawing: just use DrawText() and highlight the
461     // selected part
462     static void StandardDrawTextLine(wxDC& dc,
463                                      const wxString& text,
464                                      const wxRect& rect,
465                                      int selStart, int selEnd,
466                                      int flags);
467 
468     // standard scrollbar hit testing: this assumes that it only has 2 arrows
469     // and a thumb, so the themes which have more complicated scrollbars (e.g.
470     // BeOS) can't use this method
471     static wxRect StandardGetScrollbarRect(const wxScrollBar *scrollbar,
472                                            wxScrollBar::Element elem,
473                                            int thumbPos,
474                                            const wxSize& sizeArrow);
475     static wxHitTest StandardHitTestScrollbar(const wxScrollBar *scrollbar,
476                                               const wxPoint& pt,
477                                               const wxSize& sizeArrow);
478     static wxCoord StandardScrollbarToPixel(const wxScrollBar *scrollbar,
479                                             int thumbPos,
480                                             const wxSize& sizeArrow);
481     static int StandardPixelToScrollbar(const wxScrollBar *scrollbar,
482                                         wxCoord coord,
483                                         const wxSize& sizeArrow);
484     static wxCoord StandardScrollBarSize(const wxScrollBar *scrollbar,
485                                          const wxSize& sizeArrow);
486     static void StandardScrollBarThumbSize(wxCoord lenBar,
487                                            int thumbPos,
488                                            int thumbSize,
489                                            int range,
490                                            wxCoord *thumbStart,
491                                            wxCoord *thumbEnd);
492 };
493 
494 // ----------------------------------------------------------------------------
495 // wxDelegateRenderer: it is impossible to inherit from any of standard
496 // renderers as their declarations are in private code, but you can use this
497 // class to override only some of the Draw() functions - all the other ones
498 // will be left to the original renderer
499 // ----------------------------------------------------------------------------
500 
501 class WXDLLEXPORT wxDelegateRenderer : public wxRenderer
502 {
503 public:
wxDelegateRenderer(wxRenderer * renderer)504     wxDelegateRenderer(wxRenderer *renderer) : m_renderer(renderer) { }
505 
506     virtual void DrawBackground(wxDC& dc,
507                                 const wxColour& col,
508                                 const wxRect& rect,
509                                 int flags,
510                                 wxWindow *window = NULL )
511         { m_renderer->DrawBackground(dc, col, rect, flags, window ); }
512     virtual void DrawLabel(wxDC& dc,
513                            const wxString& label,
514                            const wxRect& rect,
515                            int flags = 0,
516                            int align = wxALIGN_LEFT | wxALIGN_TOP,
517                            int indexAccel = -1,
518                            wxRect *rectBounds = NULL)
519         { m_renderer->DrawLabel(dc, label, rect,
520                                 flags, align, indexAccel, rectBounds); }
521     virtual void DrawButtonLabel(wxDC& dc,
522                                  const wxString& label,
523                                  const wxBitmap& image,
524                                  const wxRect& rect,
525                                  int flags = 0,
526                                  int align = wxALIGN_LEFT | wxALIGN_TOP,
527                                  int indexAccel = -1,
528                                  wxRect *rectBounds = NULL)
529         { m_renderer->DrawButtonLabel(dc, label, image, rect,
530                                       flags, align, indexAccel, rectBounds); }
531     virtual void DrawBorder(wxDC& dc,
532                             wxBorder border,
533                             const wxRect& rect,
534                             int flags = 0,
535                             wxRect *rectIn = (wxRect *)NULL)
536         { m_renderer->DrawBorder(dc, border, rect, flags, rectIn); }
537     virtual void DrawTextBorder(wxDC& dc,
538                                 wxBorder border,
539                                 const wxRect& rect,
540                                 int flags = 0,
541                                 wxRect *rectIn = (wxRect *)NULL)
542         { m_renderer->DrawTextBorder(dc, border, rect, flags, rectIn); }
543     virtual void DrawButtonBorder(wxDC& dc,
544                                   const wxRect& rect,
545                                   int flags = 0,
546                                   wxRect *rectIn = (wxRect *)NULL)
547         { m_renderer->DrawButtonBorder(dc, rect, flags, rectIn); }
548     virtual void DrawFrame(wxDC& dc,
549                            const wxString& label,
550                            const wxRect& rect,
551                            int flags = 0,
552                            int align = wxALIGN_LEFT,
553                            int indexAccel = -1)
554         { m_renderer->DrawFrame(dc, label, rect, flags, align, indexAccel); }
DrawHorizontalLine(wxDC & dc,wxCoord y,wxCoord x1,wxCoord x2)555     virtual void DrawHorizontalLine(wxDC& dc,
556                                     wxCoord y, wxCoord x1, wxCoord x2)
557         { m_renderer->DrawHorizontalLine(dc, y, x1, x2); }
DrawVerticalLine(wxDC & dc,wxCoord x,wxCoord y1,wxCoord y2)558     virtual void DrawVerticalLine(wxDC& dc,
559                                   wxCoord x, wxCoord y1, wxCoord y2)
560         { m_renderer->DrawVerticalLine(dc, x, y1, y2); }
561     virtual void DrawArrow(wxDC& dc,
562                            wxDirection dir,
563                            const wxRect& rect,
564                            int flags = 0)
565         { m_renderer->DrawArrow(dc, dir, rect, flags); }
566     virtual void DrawScrollbarArrow(wxDC& dc,
567                            wxDirection dir,
568                            const wxRect& rect,
569                            int flags = 0)
570         { m_renderer->DrawScrollbarArrow(dc, dir, rect, flags); }
571     virtual void DrawScrollbarThumb(wxDC& dc,
572                                     wxOrientation orient,
573                                     const wxRect& rect,
574                                     int flags = 0)
575         { m_renderer->DrawScrollbarThumb(dc, orient, rect, flags); }
576     virtual void DrawScrollbarShaft(wxDC& dc,
577                                     wxOrientation orient,
578                                     const wxRect& rect,
579                                     int flags = 0)
580         { m_renderer->DrawScrollbarShaft(dc, orient, rect, flags); }
DrawScrollCorner(wxDC & dc,const wxRect & rect)581     virtual void DrawScrollCorner(wxDC& dc,
582                                   const wxRect& rect)
583         { m_renderer->DrawScrollCorner(dc, rect); }
584     virtual void DrawItem(wxDC& dc,
585                           const wxString& label,
586                           const wxRect& rect,
587                           int flags = 0)
588         { m_renderer->DrawItem(dc, label, rect, flags); }
589     virtual void DrawCheckItem(wxDC& dc,
590                                const wxString& label,
591                                const wxBitmap& bitmap,
592                                const wxRect& rect,
593                                int flags = 0)
594         { m_renderer->DrawCheckItem(dc, label, bitmap, rect, flags); }
595     virtual void DrawCheckButton(wxDC& dc,
596                                  const wxString& label,
597                                  const wxBitmap& bitmap,
598                                  const wxRect& rect,
599                                  int flags = 0,
600                                  wxAlignment align = wxALIGN_LEFT,
601                                  int indexAccel = -1)
602         { m_renderer->DrawCheckButton(dc, label, bitmap, rect,
603                                       flags, align, indexAccel); }
604     virtual void DrawRadioButton(wxDC& dc,
605                                  const wxString& label,
606                                  const wxBitmap& bitmap,
607                                  const wxRect& rect,
608                                  int flags = 0,
609                                  wxAlignment align = wxALIGN_LEFT,
610                                  int indexAccel = -1)
611         { m_renderer->DrawRadioButton(dc, label, bitmap, rect,
612                                       flags, align, indexAccel); }
613     virtual void DrawToolBarButton(wxDC& dc,
614                                    const wxString& label,
615                                    const wxBitmap& bitmap,
616                                    const wxRect& rect,
617                                    int flags = 0)
618         { m_renderer->DrawToolBarButton(dc, label, bitmap, rect, flags); }
619     virtual void DrawTextLine(wxDC& dc,
620                               const wxString& text,
621                               const wxRect& rect,
622                               int selStart = -1,
623                               int selEnd = -1,
624                               int flags = 0)
625         { m_renderer->DrawTextLine(dc, text, rect, selStart, selEnd, flags); }
DrawLineWrapMark(wxDC & dc,const wxRect & rect)626     virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect)
627         { m_renderer->DrawLineWrapMark(dc, rect); }
628 
629     virtual void DrawTab(wxDC& dc,
630                          const wxRect& rect,
631                          wxDirection dir,
632                          const wxString& label,
633                          const wxBitmap& bitmap = wxNullBitmap,
634                          int flags = 0,
635                          int accel = -1)
636         { m_renderer->DrawTab(dc, rect, dir, label, bitmap, flags, accel); }
637 
638     virtual void DrawSliderShaft(wxDC& dc,
639                                  const wxRect& rect,
640                                  wxOrientation orient,
641                                  int flags = 0,
642                                  wxRect *rectShaft = NULL)
643         { m_renderer->DrawSliderShaft(dc, rect, orient, flags, rectShaft); }
644     virtual void DrawSliderThumb(wxDC& dc,
645                                  const wxRect& rect,
646                                  wxOrientation orient,
647                                  int flags = 0)
648         { m_renderer->DrawSliderThumb(dc, rect, orient, flags); }
649     virtual void DrawSliderTicks(wxDC& dc,
650                                  const wxRect& rect,
651                                  const wxSize& sizeThumb,
652                                  wxOrientation orient,
653                                  int start,
654                                  int end,
655                                  int step = 1,
656                                  int flags = 0)
657         { m_renderer->DrawSliderTicks(dc, rect, sizeThumb, orient,
658                                       start, end, start, flags); }
659 
660     virtual void DrawMenuBarItem(wxDC& dc,
661                                  const wxRect& rect,
662                                  const wxString& label,
663                                  int flags = 0,
664                                  int indexAccel = -1)
665         { m_renderer->DrawMenuBarItem(dc, rect, label, flags, indexAccel); }
666     virtual void DrawMenuItem(wxDC& dc,
667                               wxCoord y,
668                               const wxMenuGeometryInfo& gi,
669                               const wxString& label,
670                               const wxString& accel,
671                               const wxBitmap& bitmap = wxNullBitmap,
672                               int flags = 0,
673                               int indexAccel = -1)
674         { m_renderer->DrawMenuItem(dc, y, gi, label, accel,
675                                    bitmap, flags, indexAccel); }
DrawMenuSeparator(wxDC & dc,wxCoord y,const wxMenuGeometryInfo & geomInfo)676     virtual void DrawMenuSeparator(wxDC& dc,
677                                    wxCoord y,
678                                    const wxMenuGeometryInfo& geomInfo)
679         { m_renderer->DrawMenuSeparator(dc, y, geomInfo); }
680 
681     virtual void DrawStatusField(wxDC& dc,
682                                  const wxRect& rect,
683                                  const wxString& label,
684                                  int flags = 0)
685         { m_renderer->DrawStatusField(dc, rect, label, flags); }
686 
687     virtual void DrawFrameTitleBar(wxDC& dc,
688                                    const wxRect& rect,
689                                    const wxString& title,
690                                    const wxIcon& icon,
691                                    int flags,
692                                    int specialButton = 0,
693                                    int specialButtonFlag = 0)
694         { m_renderer->DrawFrameTitleBar(dc, rect, title, icon, flags,
695                                         specialButton, specialButtonFlag); }
DrawFrameBorder(wxDC & dc,const wxRect & rect,int flags)696     virtual void DrawFrameBorder(wxDC& dc,
697                                  const wxRect& rect,
698                                  int flags)
699         { m_renderer->DrawFrameBorder(dc, rect, flags); }
DrawFrameBackground(wxDC & dc,const wxRect & rect,int flags)700     virtual void DrawFrameBackground(wxDC& dc,
701                                      const wxRect& rect,
702                                      int flags)
703         { m_renderer->DrawFrameBackground(dc, rect, flags); }
DrawFrameTitle(wxDC & dc,const wxRect & rect,const wxString & title,int flags)704     virtual void DrawFrameTitle(wxDC& dc,
705                                 const wxRect& rect,
706                                 const wxString& title,
707                                 int flags)
708         { m_renderer->DrawFrameTitle(dc, rect, title, flags); }
DrawFrameIcon(wxDC & dc,const wxRect & rect,const wxIcon & icon,int flags)709     virtual void DrawFrameIcon(wxDC& dc,
710                                const wxRect& rect,
711                                const wxIcon& icon,
712                                int flags)
713         { m_renderer->DrawFrameIcon(dc, rect, icon, flags); }
714     virtual void DrawFrameButton(wxDC& dc,
715                                  wxCoord x, wxCoord y,
716                                  int button,
717                                  int flags = 0)
718         { m_renderer->DrawFrameButton(dc, x, y, button, flags); }
719 
GetComboBitmaps(wxBitmap * bmpNormal,wxBitmap * bmpFocus,wxBitmap * bmpPressed,wxBitmap * bmpDisabled)720     virtual void GetComboBitmaps(wxBitmap *bmpNormal,
721                                  wxBitmap *bmpFocus,
722                                  wxBitmap *bmpPressed,
723                                  wxBitmap *bmpDisabled)
724         { m_renderer->GetComboBitmaps(bmpNormal, bmpFocus,
725                                       bmpPressed, bmpDisabled); }
726 
AdjustSize(wxSize * size,const wxWindow * window)727     virtual void AdjustSize(wxSize *size, const wxWindow *window)
728         { m_renderer->AdjustSize(size, window); }
GetBorderDimensions(wxBorder border)729     virtual wxRect GetBorderDimensions(wxBorder border) const
730         { return m_renderer->GetBorderDimensions(border); }
AreScrollbarsInsideBorder()731     virtual bool AreScrollbarsInsideBorder() const
732         { return m_renderer->AreScrollbarsInsideBorder(); }
733 
GetScrollbarArrowSize()734     virtual wxSize GetScrollbarArrowSize() const
735         { return m_renderer->GetScrollbarArrowSize(); }
736     virtual wxRect GetScrollbarRect(const wxScrollBar *scrollbar,
737                                     wxScrollBar::Element elem,
738                                     int thumbPos = -1) const
739         { return m_renderer->GetScrollbarRect(scrollbar, elem, thumbPos); }
GetScrollbarSize(const wxScrollBar * scrollbar)740     virtual wxCoord GetScrollbarSize(const wxScrollBar *scrollbar)
741         { return m_renderer->GetScrollbarSize(scrollbar); }
HitTestScrollbar(const wxScrollBar * scrollbar,const wxPoint & pt)742     virtual wxHitTest HitTestScrollbar(const wxScrollBar *scrollbar,
743                                        const wxPoint& pt) const
744         { return m_renderer->HitTestScrollbar(scrollbar, pt); }
745     virtual wxCoord ScrollbarToPixel(const wxScrollBar *scrollbar,
746                                      int thumbPos = -1)
747         { return m_renderer->ScrollbarToPixel(scrollbar, thumbPos); }
PixelToScrollbar(const wxScrollBar * scrollbar,wxCoord coord)748     virtual int PixelToScrollbar(const wxScrollBar *scrollbar,
749                                  wxCoord coord)
750         { return m_renderer->PixelToScrollbar(scrollbar, coord); }
GetListboxItemHeight(wxCoord fontHeight)751     virtual wxCoord GetListboxItemHeight(wxCoord fontHeight)
752         { return m_renderer->GetListboxItemHeight(fontHeight); }
GetCheckBitmapSize()753     virtual wxSize GetCheckBitmapSize() const
754         { return m_renderer->GetCheckBitmapSize(); }
GetRadioBitmapSize()755     virtual wxSize GetRadioBitmapSize() const
756         { return m_renderer->GetRadioBitmapSize(); }
GetCheckItemMargin()757     virtual wxCoord GetCheckItemMargin() const
758         { return m_renderer->GetCheckItemMargin(); }
759 
GetToolBarButtonSize(wxCoord * separator)760     virtual wxSize GetToolBarButtonSize(wxCoord *separator) const
761         { return m_renderer->GetToolBarButtonSize(separator); }
GetToolBarMargin()762     virtual wxSize GetToolBarMargin() const
763         { return m_renderer->GetToolBarMargin(); }
764 
GetTextTotalArea(const wxTextCtrl * text,const wxRect & rect)765     virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
766                                     const wxRect& rect) const
767         { return m_renderer->GetTextTotalArea(text, rect); }
GetTextClientArea(const wxTextCtrl * text,const wxRect & rect,wxCoord * extraSpaceBeyond)768     virtual wxRect GetTextClientArea(const wxTextCtrl *text,
769                                      const wxRect& rect,
770                                      wxCoord *extraSpaceBeyond) const
771         { return m_renderer->GetTextClientArea(text, rect, extraSpaceBeyond); }
772 
GetTabIndent()773     virtual wxSize GetTabIndent() const { return m_renderer->GetTabIndent(); }
GetTabPadding()774     virtual wxSize GetTabPadding() const { return m_renderer->GetTabPadding(); }
775 
GetSliderDim()776     virtual wxCoord GetSliderDim() const
777         { return m_renderer->GetSliderDim(); }
GetSliderTickLen()778     virtual wxCoord GetSliderTickLen() const
779         { return m_renderer->GetSliderTickLen(); }
GetSliderShaftRect(const wxRect & rect,wxOrientation orient)780     virtual wxRect GetSliderShaftRect(const wxRect& rect,
781                                       wxOrientation orient) const
782         { return m_renderer->GetSliderShaftRect(rect, orient); }
GetSliderThumbSize(const wxRect & rect,wxOrientation orient)783     virtual wxSize GetSliderThumbSize(const wxRect& rect,
784                                       wxOrientation orient) const
785         { return m_renderer->GetSliderThumbSize(rect, orient); }
GetProgressBarStep()786     virtual wxSize GetProgressBarStep() const
787         { return m_renderer->GetProgressBarStep(); }
GetMenuBarItemSize(const wxSize & sizeText)788     virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const
789         { return m_renderer->GetMenuBarItemSize(sizeText); }
GetMenuGeometry(wxWindow * win,const wxMenu & menu)790     virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
791                                                 const wxMenu& menu) const
792         { return m_renderer->GetMenuGeometry(win, menu); }
GetStatusBarBorders(wxCoord * borderBetweenFields)793     virtual wxSize GetStatusBarBorders(wxCoord *borderBetweenFields) const
794         { return m_renderer->GetStatusBarBorders(borderBetweenFields); }
GetFrameClientArea(const wxRect & rect,int flags)795     virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const
796         { return m_renderer->GetFrameClientArea(rect, flags); }
GetFrameTotalSize(const wxSize & clientSize,int flags)797     virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const
798         { return m_renderer->GetFrameTotalSize(clientSize, flags); }
GetFrameMinSize(int flags)799     virtual wxSize GetFrameMinSize(int flags) const
800         { return m_renderer->GetFrameMinSize(flags); }
GetFrameIconSize()801     virtual wxSize GetFrameIconSize() const
802         { return m_renderer->GetFrameIconSize(); }
HitTestFrame(const wxRect & rect,const wxPoint & pt,int flags)803     virtual int HitTestFrame(const wxRect& rect,
804                              const wxPoint& pt,
805                              int flags) const
806         { return m_renderer->HitTestFrame(rect, pt, flags); }
807 
808 protected:
809     wxRenderer *m_renderer;
810 };
811 
812 // ----------------------------------------------------------------------------
813 // wxControlRenderer: wraps the wxRenderer functions in a form easy to use from
814 // OnPaint()
815 // ----------------------------------------------------------------------------
816 
817 class WXDLLEXPORT wxControlRenderer
818 {
819 public:
820     // create a renderer for this dc with this "fundamental" renderer
821     wxControlRenderer(wxWindow *control, wxDC& dc, wxRenderer *renderer);
822 
823     // operations
824     void DrawLabel(const wxBitmap& bitmap = wxNullBitmap,
825                    wxCoord marginX = 0, wxCoord marginY = 0);
826 #if wxUSE_LISTBOX
827     void DrawItems(const wxListBox *listbox,
828                    size_t itemFirst, size_t itemLast);
829 #endif // wxUSE_LISTBOX
830 #if wxUSE_CHECKLISTBOX
831     void DrawCheckItems(const wxCheckListBox *listbox,
832                         size_t itemFirst, size_t itemLast);
833 #endif // wxUSE_CHECKLISTBOX
834     void DrawButtonBorder();
835     // the line must be either horizontal or vertical
836     void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
837     void DrawFrame();
838     void DrawBitmap(const wxBitmap& bitmap);
839     void DrawBackgroundBitmap();
840     void DrawScrollbar(const wxScrollBar *scrollbar, int thumbPosOld);
841 #if wxUSE_GAUGE
842     void DrawProgressBar(const wxGauge *gauge);
843 #endif // wxUSE_GAUGE
844 
845     // accessors
GetWindow()846     wxWindow *GetWindow() const { return m_window; }
GetRenderer()847     wxRenderer *GetRenderer() const { return m_renderer; }
848 
GetDC()849     wxDC& GetDC() { return m_dc; }
850 
GetRect()851     const wxRect& GetRect() const { return m_rect; }
GetRect()852     wxRect& GetRect() { return m_rect; }
853 
854     // static helpers
855     static void DrawBitmap(wxDC &dc,
856                            const wxBitmap& bitmap,
857                            const wxRect& rect,
858                            int alignment = wxALIGN_CENTRE |
859                                            wxALIGN_CENTRE_VERTICAL,
860                            wxStretch stretch = wxSTRETCH_NOT);
861 
862 private:
863     // common part of DrawItems() and DrawCheckItems()
864     void DoDrawItems(const wxListBox *listbox,
865                      size_t itemFirst, size_t itemLast,
866                      bool isCheckLbox = FALSE);
867 
868     wxWindow *m_window;
869     wxRenderer *m_renderer;
870     wxDC& m_dc;
871     wxRect m_rect;
872 };
873 
874 #endif // _WX_UNIV_RENDERER_H_
875 
876