]> git.saurik.com Git - wxWidgets.git/blame - src/univ/stdrend.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
1552971 ] Add flag for wxODComboBox::OnDrawItem to indicate selection
[wxWidgets.git] / src / univ / stdrend.cpp
CommitLineData
147b8a4a
VZ		 1///////////////////////////////////////////////////////////////////////////////
2// Name: src/univ/stdrend.cpp
3// Purpose: implementation of wxStdRenderer
4// Author: Vadim Zeitlin
5// Created: 2006-09-16
6// RCS-ID: $Id$
7// Copyright: (c) 2006 Vadim Zeitlin <vadim@wxwindows.org>
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#endif //WX_PRECOMP
28
29#include "wx/univ/stdrend.h"
30#include "wx/univ/colschem.h"
31
32// ============================================================================
33// wxStdRenderer implementation
34// ============================================================================
35
36// ----------------------------------------------------------------------------
37// ctor
38// ----------------------------------------------------------------------------
39
40wxStdRenderer::wxStdRenderer(const wxColourScheme *scheme)
41 : m_scheme(scheme)
42{
43 m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK));
44 m_penDarkGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT));
45 m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN));
46 m_penHighlight = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT));
47}
48
49// ----------------------------------------------------------------------------
50// helper functions
51// ----------------------------------------------------------------------------
52
53void
54wxStdRenderer::DrawSolidRect(wxDC& dc, const wxColour& col, const wxRect& rect)
55{
56 wxBrush brush(col, wxSOLID);
57 dc.SetBrush(brush);
58 dc.SetPen(*wxTRANSPARENT_PEN);
59 dc.DrawRectangle(rect);
60}
61
62void wxStdRenderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
63{
64 // draw
65 dc.SetPen(pen);
66 dc.SetBrush(*wxTRANSPARENT_BRUSH);
67 dc.DrawRectangle(*rect);
68
69 // adjust the rect
70 rect->Inflate(-1);
71}
72
73void wxStdRenderer::DrawShadedRect(wxDC& dc, wxRect *rect,
74 const wxPen& pen1, const wxPen& pen2)
75{
76 // draw the rectangle
77 dc.SetPen(pen1);
78 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
79 rect->GetLeft(), rect->GetBottom());
80 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
81 rect->GetRight(), rect->GetTop());
82 dc.SetPen(pen2);
83 dc.DrawLine(rect->GetRight(), rect->GetTop(),
84 rect->GetRight(), rect->GetBottom());
85 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
86 rect->GetRight() + 1, rect->GetBottom());
87
88 // adjust the rect
89 rect->Inflate(-1);
90}
91
92// ----------------------------------------------------------------------------
93// background
94// ----------------------------------------------------------------------------
95
96void wxStdRenderer::DrawBackground(wxDC& dc,
97 const wxColour& col,
98 const wxRect& rect,
99 int WXUNUSED(flags),
100 wxWindow *window)
101{
102 wxColour colBg = col.Ok() ? col
103 : window ? m_scheme->GetBackground(window)
104 : wxSCHEME_COLOUR(m_scheme, CONTROL);
105
106 DrawSolidRect(dc, colBg, rect);
107}
108
109
110void wxStdRenderer::DrawButtonSurface(wxDC& dc,
111 const wxColour& col,
112 const wxRect& rect,
113 int flags)
114{
115 DrawBackground(dc, col, rect, flags);
116}
117
118// ----------------------------------------------------------------------------
119// text
120// ----------------------------------------------------------------------------
121
122void wxStdRenderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
123{
124 // draw the pixels manually because the "dots" in wxPen with wxDOT style
125 // may be short traits and not really dots
126 //
127 // note that to behave in the same manner as DrawRect(), we must exclude
128 // the bottom and right borders from the rectangle
129 wxCoord x1 = rect.GetLeft(),
130 y1 = rect.GetTop(),
131 x2 = rect.GetRight(),
132 y2 = rect.GetBottom();
133
134 dc.SetPen(m_penBlack);
135
136 // this seems to be closer than what Windows does than wxINVERT although
137 // I'm still not sure if it's correct
138 dc.SetLogicalFunction(wxAND_REVERSE);
139
140 wxCoord z;
141 for ( z = x1 + 1; z < x2; z += 2 )
142 dc.DrawPoint(z, rect.GetTop());
143
144 wxCoord shift = z == x2 ? 0 : 1;
145 for ( z = y1 + shift; z < y2; z += 2 )
146 dc.DrawPoint(x2, z);
147
148 shift = z == y2 ? 0 : 1;
149 for ( z = x2 - shift; z > x1; z -= 2 )
150 dc.DrawPoint(z, y2);
151
152 shift = z == x1 ? 0 : 1;
153 for ( z = y2 - shift; z > y1; z -= 2 )
154 dc.DrawPoint(x1, z);
155
156 dc.SetLogicalFunction(wxCOPY);
157}
158
159void wxStdRenderer::DrawLabel(wxDC& dc,
160 const wxString& label,
161 const wxRect& rect,
162 int flags,
163 int alignment,
164 int indexAccel,
165 wxRect *rectBounds)
166{
167 DrawButtonLabel(dc, label, wxNullBitmap, rect, flags,
168 alignment, indexAccel, rectBounds);
169}
170
171void wxStdRenderer::DrawButtonLabel(wxDC& dc,
172 const wxString& label,
173 const wxBitmap& image,
174 const wxRect& rect,
175 int flags,
176 int alignment,
177 int indexAccel,
178 wxRect *rectBounds)
179{
180 wxRect rectLabel = rect;
181 if ( !label.empty() && (flags & wxCONTROL_DISABLED) )
182 {
183 if ( flags & wxCONTROL_PRESSED )
184 {
185 // shift the label if a button is pressed
186 rectLabel.Offset(1, 1);
187 }
188
189 // draw shadow of the text
190 dc.SetTextForeground(m_penHighlight.GetColour());
191 wxRect rectShadow = rect;
192 rectShadow.Offset(1, 1);
193 dc.DrawLabel(label, rectShadow, alignment, indexAccel);
194
195 // make the main label text grey
196 dc.SetTextForeground(m_penDarkGrey.GetColour());
197
198 if ( flags & wxCONTROL_FOCUSED )
199 {
200 // leave enough space for the focus rect
201 rectLabel.Inflate(-2);
202 }
203 }
204
205 dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
206
207 if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
208 {
209 rectLabel.Inflate(-1);
210
211 DrawFocusRect(dc, rectLabel);
212 }
213}
214
215// ----------------------------------------------------------------------------
216// borders
217// ----------------------------------------------------------------------------
218
219/*
220 We implement standard-looking 3D borders which have the following appearance:
221
222 The raised border:
223
224 WWWWWWWWWWWWWWWWWWWWWWB
225 WHHHHHHHHHHHHHHHHHHHHGB
226 WH GB W = white (HILIGHT)
227 WH GB H = light grey (LIGHT)
228 WH GB G = dark grey (SHADOI)
229 WH GB B = black (DKSHADOI)
230 WH GB
231 WH GB
232 WGGGGGGGGGGGGGGGGGGGGGB
233 BBBBBBBBBBBBBBBBBBBBBBB
234
235 The sunken border looks like this:
236
237 GGGGGGGGGGGGGGGGGGGGGGW
238 GBBBBBBBBBBBBBBBBBBBBHW
239 GB HW
240 GB HW
241 GB HW
242 GB HW
243 GB HW
244 GB HW
245 GHHHHHHHHHHHHHHHHHHHHHW
246 WWWWWWWWWWWWWWWWWWWWWWW
247
248 The static border (used for the controls which don't get focus) is like
249 this:
250
251 GGGGGGGGGGGGGGGGGGGGGGW
252 G W
253 G W
254 G W
255 G W
256 G W
257 G W
258 G W
259 WWWWWWWWWWWWWWWWWWWWWWW
260
261 The most complicated is the double border which is a combination of special
262 "anti-sunken" border and an extra border inside it:
263
264 HHHHHHHHHHHHHHHHHHHHHHB
265 HWWWWWWWWWWWWWWWWWWWWGB
266 HWHHHHHHHHHHHHHHHHHHHGB
267 HWH HGB
268 HWH HGB
269 HWH HGB
270 HWH HGB
271 HWHHHHHHHHHHHHHHHHHHHGB
272 HGGGGGGGGGGGGGGGGGGGGGB
273 BBBBBBBBBBBBBBBBBBBBBBB
274
275 And the simple border is, well, simple:
276
277 BBBBBBBBBBBBBBBBBBBBBBB
278 B B
279 B B
280 B B
281 B B
282 B B
283 B B
284 B B
285 B B
286 BBBBBBBBBBBBBBBBBBBBBBB
287*/
288
289void wxStdRenderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
290{
291 DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
292 DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
293}
294
295void wxStdRenderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
296{
297 DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
298 DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
299}
300
301void wxStdRenderer::DrawAntiSunkenBorder(wxDC& dc, wxRect *rect)
302{
303 DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
304 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
305}
306
307void wxStdRenderer::DrawBorder(wxDC& dc,
308 wxBorder border,
309 const wxRect& rectTotal,
310 int WXUNUSED(flags),
311 wxRect *rectIn)
312{
313 wxRect rect = rectTotal;
314
315 switch ( border )
316 {
317 case wxBORDER_SUNKEN:
318 DrawSunkenBorder(dc, &rect);
319 break;
320
321 case wxBORDER_DOUBLE:
322 DrawAntiSunkenBorder(dc, &rect);
323 DrawRect(dc, &rect, m_penLightGrey);
324 break;
325
326 case wxBORDER_STATIC:
327 DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
328 break;
329
330 case wxBORDER_RAISED:
331 DrawRaisedBorder(dc, &rect);
332 break;
333
334 case wxBORDER_SIMPLE:
335 DrawRect(dc, &rect, m_penBlack);
336 break;
337
338 default:
339 wxFAIL_MSG(_T("unknown border type"));
340 // fall through
341
342 case wxBORDER_DEFAULT:
343 case wxBORDER_NONE:
344 break;
345 }
346
347 if ( rectIn )
348 *rectIn = rect;
349}
350
351wxRect wxStdRenderer::GetBorderDimensions(wxBorder border) const
352{
353 wxCoord width;
354 switch ( border )
355 {
356 case wxBORDER_SIMPLE:
357 case wxBORDER_STATIC:
358 width = 1;
359 break;
360
361 case wxBORDER_RAISED:
362 case wxBORDER_SUNKEN:
363 width = 2;
364 break;
365
366 case wxBORDER_DOUBLE:
367 width = 3;
368 break;
369
370 default:
371 wxFAIL_MSG(_T("unknown border type"));
372 // fall through
373
374 case wxBORDER_DEFAULT:
375 case wxBORDER_NONE:
376 width = 0;
377 break;
378 }
379
380 wxRect rect;
381 rect.x =
382 rect.y =
383 rect.width =
384 rect.height = width;
385
386 return rect;
387}
388
389bool wxStdRenderer::AreScrollbarsInsideBorder() const
390{
391 return false;
392}
393
394void wxStdRenderer::DrawTextBorder(wxDC& dc,
395 wxBorder border,
396 const wxRect& rect,
397 int flags,
398 wxRect *rectIn)
399{
400 DrawBorder(dc, border, rect, flags, rectIn);
401}
402
403// ----------------------------------------------------------------------------
404// lines and boxes
405// ----------------------------------------------------------------------------
406
407void
408wxStdRenderer::DrawHorizontalLine(wxDC& dc, wxCoord y, wxCoord x1, wxCoord x2)
409{
410 dc.SetPen(m_penDarkGrey);
411 dc.DrawLine(x1, y, x2 + 1, y);
412
413 dc.SetPen(m_penHighlight);
414 y++;
415 dc.DrawLine(x1, y, x2 + 1, y);
416}
417
418void
419wxStdRenderer::DrawVerticalLine(wxDC& dc, wxCoord x, wxCoord y1, wxCoord y2)
420{
421 dc.SetPen(m_penDarkGrey);
422 dc.DrawLine(x, y1, x, y2 + 1);
423
424 dc.SetPen(m_penHighlight);
425 x++;
426 dc.DrawLine(x, y1, x, y2 + 1);
427}
428
429void wxStdRenderer::DrawFrameWithoutLabel(wxDC& dc,
430 const wxRect& rectFrame,
431 const wxRect& rectLabel)
432{
433 // draw left, bottom and right lines entirely
434 DrawVerticalLine(dc, rectFrame.GetLeft(),
435 rectFrame.GetTop(), rectFrame.GetBottom() - 2);
436 DrawHorizontalLine(dc, rectFrame.GetBottom() - 1,
437 rectFrame.GetLeft(), rectFrame.GetRight());
438 DrawVerticalLine(dc, rectFrame.GetRight() - 1,
439 rectFrame.GetTop(), rectFrame.GetBottom() - 1);
440
441 // and 2 parts of the top line
442 DrawHorizontalLine(dc, rectFrame.GetTop(),
443 rectFrame.GetLeft() + 1, rectLabel.GetLeft());
444 DrawHorizontalLine(dc, rectFrame.GetTop(),
445 rectLabel.GetRight(), rectFrame.GetRight() - 2);
446}
447
448void wxStdRenderer::DrawFrameWithLabel(wxDC& dc,
449 const wxString& label,
450 const wxRect& rectFrame,
451 const wxRect& rectText,
452 int flags,
453 int alignment,
454 int indexAccel)
455{
456 wxRect rectLabel;
457 DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
458
459 DrawFrameWithoutLabel(dc, rectFrame, rectLabel);
460}
461
462void wxStdRenderer::DrawFrame(wxDC& dc,
463 const wxString& label,
464 const wxRect& rect,
465 int flags,
466 int alignment,
467 int indexAccel)
468{
469 wxCoord height = 0; // of the label
470 wxRect rectFrame = rect;
471 if ( !label.empty() )
472 {
473 // the text should touch the top border of the rect, so the frame
474 // itself should be lower
475 dc.GetTextExtent(label, NULL, &height);
476 rectFrame.y += height / 2;
477 rectFrame.height -= height / 2;
478
479 // we have to draw each part of the frame individually as we can't
480 // erase the background beyond the label as it might contain some
481 // pixmap already, so drawing everything and then overwriting part of
482 // the frame with label doesn't work
483
484 // TODO: the +5 shouldn't be hard coded
485 wxRect rectText;
486 rectText.x = rectFrame.x + 5;
487 rectText.y = rect.y;
488 rectText.width = rectFrame.width - 7; // +2 border width
489 rectText.height = height;
490
491 DrawFrameWithLabel(dc, label, rectFrame, rectText, flags,
492 alignment, indexAccel);
493 }
494 else // no label
495 {
496 // just draw the complete frame
497 DrawShadedRect(dc, &rectFrame, m_penDarkGrey, m_penHighlight);
498 DrawShadedRect(dc, &rectFrame, m_penHighlight, m_penDarkGrey);
499 }
500}
501
502void wxStdRenderer::DrawItem(wxDC& dc,
503 const wxString& label,
504 const wxRect& rect,
505 int flags)
506{
507 wxDCTextColourChanger colChanger(dc);
508
509 if ( flags & wxCONTROL_SELECTED )
510 {
511 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
512
513 const wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
514 dc.SetBrush(colBg);
515 dc.SetPen(colBg);
516 dc.DrawRectangle(rect);
517 }
518
519 wxRect rectText = rect;
520 rectText.x += 2;
521 rectText.width -= 2;
522 dc.DrawLabel(label, wxNullBitmap, rectText);
523
524 if ( flags & wxCONTROL_FOCUSED )
525 {
526 DrawFocusRect(dc, rect);
527 }
528}
529
530// ----------------------------------------------------------------------------
531// check and radio bitmaps
532// ----------------------------------------------------------------------------
533
534/* static */
535void wxStdRenderer::GetIndicatorsFromFlags(int flags,
536 IndicatorState& state,
537 IndicatorStatus& status)
538{
539 if ( flags & wxCONTROL_SELECTED )
540 state = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
541 : IndicatorState_Selected;
542 else if ( flags & wxCONTROL_DISABLED )
543 state = IndicatorState_Disabled;
544 else if ( flags & wxCONTROL_PRESSED )
545 state = IndicatorState_Pressed;
546 else
547 state = IndicatorState_Normal;
548
549 status = flags & wxCONTROL_CHECKED ? IndicatorStatus_Checked
550 : flags & wxCONTROL_UNDETERMINED
551 ? IndicatorStatus_Undetermined
552 : IndicatorStatus_Unchecked;
553}
554
555void wxStdRenderer::DrawCheckButton(wxDC& dc,
556 const wxString& label,
557 const wxBitmap& bitmap,
558 const wxRect& rect,
559 int flags,
560 wxAlignment align,
561 int indexAccel)
562{
563 wxBitmap bmp(bitmap.Ok() ? bitmap : GetCheckBitmap(flags));
564
565 DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
566}
567
568void wxStdRenderer::DrawRadioButton(wxDC& dc,
569 const wxString& label,
570 const wxBitmap& bitmap,
571 const wxRect& rect,
572 int flags,
573 wxAlignment align,
574 int indexAccel)
575{
576 wxBitmap bmp(bitmap.Ok() ? bitmap : GetRadioBitmap(flags));
577
578 DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
579}
580
581void wxStdRenderer::DrawCheckOrRadioButton(wxDC& dc,
582 const wxString& label,
583 const wxBitmap& bitmap,
584 const wxRect& rect,
585 int flags,
586 wxAlignment align,
587 int indexAccel)
588{
589 // calculate the position of the bitmap and of the label
590 wxCoord heightBmp = bitmap.GetHeight();
591 wxCoord xBmp,
592 yBmp = rect.y + (rect.height - heightBmp) / 2;
593
594 wxRect rectLabel;
595 dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
596 rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
597
598 // align label vertically with the bitmap - looks nicer like this
599 rectLabel.y -= (rectLabel.height - heightBmp) % 2;
600
601 // calc horz position
602 if ( align == wxALIGN_RIGHT )
603 {
604 xBmp = rect.GetRight() - bitmap.GetWidth();
605 rectLabel.x = rect.x + 3;
606 rectLabel.SetRight(xBmp);
607 }
608 else // normal (checkbox to the left of the text) case
609 {
610 xBmp = rect.x;
611 rectLabel.x = xBmp + bitmap.GetWidth() + 5;
612 rectLabel.SetRight(rect.GetRight());
613 }
614
615 dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
616
617 DrawLabel(dc, label, rectLabel, flags,
618 wxALIGN_LEFT | wxALIGN_TOP, indexAccel);
619}
620
621#if wxUSE_TEXTCTRL
622
623void wxStdRenderer::DrawTextLine(wxDC& dc,
624 const wxString& text,
625 const wxRect& rect,
626 int selStart,
627 int selEnd,
628 int flags)
629{
630 if ( (selStart == -1) || !(flags & wxCONTROL_FOCUSED) )
631 {
632 // just draw it as is
633 dc.DrawText(text, rect.x, rect.y);
634 }
635 else // we have selection
636 {
637 wxCoord width,
638 x = rect.x;
639
640 // draw the part before selection
641 wxString s(text, (size_t)selStart);
642 if ( !s.empty() )
643 {
644 dc.DrawText(s, x, rect.y);
645
646 dc.GetTextExtent(s, &width, NULL);
647 x += width;
648 }
649
650 // draw the selection itself
651 s = wxString(text.c_str() + selStart, text.c_str() + selEnd);
652 if ( !s.empty() )
653 {
654 wxColour colFg = dc.GetTextForeground(),
655 colBg = dc.GetTextBackground();
656 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
657 dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT));
658 dc.SetBackgroundMode(wxSOLID);
659
660 dc.DrawText(s, x, rect.y);
661 dc.GetTextExtent(s, &width, NULL);
662 x += width;
663
664 dc.SetBackgroundMode(wxTRANSPARENT);
665 dc.SetTextBackground(colBg);
666 dc.SetTextForeground(colFg);
667 }
668
669 // draw the final part
670 s = text.c_str() + selEnd;
671 if ( !s.empty() )
672 {
673 dc.DrawText(s, x, rect.y);
674 }
675 }
676}
677
678void wxStdRenderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
679 const wxRect& WXUNUSED(rect))
680{
681 // nothing by default
682}
683
684#endif // wxUSE_TEXTCTRL
685
686// ----------------------------------------------------------------------------
687// scrollbars geometry
688// ----------------------------------------------------------------------------
689
690#if wxUSE_SCROLLBAR
691
692/* static */
693void wxStdRenderer::GetScrollBarThumbSize(wxCoord length,
694 int thumbPos,
695 int thumbSize,
696 int range,
697 wxCoord *thumbStart,
698 wxCoord *thumbEnd)
699{
700 // the thumb can't be made less than this number of pixels
701 static const wxCoord thumbMinWidth = 8; // FIXME: should be configurable
702
703 *thumbStart = (length*thumbPos) / range;
704 *thumbEnd = (length*(thumbPos + thumbSize)) / range;
705
706 if ( *thumbEnd - *thumbStart < thumbMinWidth )
707 {
708 // adjust the end if possible
709 if ( *thumbStart <= length - thumbMinWidth )
710 {
711 // yes, just make it wider
712 *thumbEnd = *thumbStart + thumbMinWidth;
713 }
714 else // it is at the bottom of the scrollbar
715 {
716 // so move it a bit up
717 *thumbStart = length - thumbMinWidth;
718 *thumbEnd = length;
719 }
720 }
721}
722
723wxRect wxStdRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
724 wxScrollBar::Element elem,
725 int thumbPos) const
726{
727 if ( thumbPos == -1 )
728 {
729 thumbPos = scrollbar->GetThumbPosition();
730 }
731
732 const wxSize sizeArrow = GetScrollbarArrowSize();
733
734 wxSize sizeTotal = scrollbar->GetClientSize();
735 wxCoord *start, *width;
736 wxCoord length, arrow;
737 wxRect rect;
738 if ( scrollbar->IsVertical() )
739 {
740 rect.x = 0;
741 rect.width = sizeTotal.x;
742 length = sizeTotal.y;
743 start = &rect.y;
744 width = &rect.height;
745 arrow = sizeArrow.y;
746 }
747 else // horizontal
748 {
749 rect.y = 0;
750 rect.height = sizeTotal.y;
751 length = sizeTotal.x;
752 start = &rect.x;
753 width = &rect.width;
754 arrow = sizeArrow.x;
755 }
756
757 switch ( elem )
758 {
759 case wxScrollBar::Element_Arrow_Line_1:
760 *start = 0;
761 *width = arrow;
762 break;
763
764 case wxScrollBar::Element_Arrow_Line_2:
765 *start = length - arrow;
766 *width = arrow;
767 break;
768
769 case wxScrollBar::Element_Arrow_Page_1:
770 case wxScrollBar::Element_Arrow_Page_2:
771 // we don't have them at all
772 break;
773
774 case wxScrollBar::Element_Thumb:
775 case wxScrollBar::Element_Bar_1:
776 case wxScrollBar::Element_Bar_2:
777 // we need to calculate the thumb position - do it
778 {
779 length -= 2*arrow;
780 wxCoord thumbStart, thumbEnd;
781 int range = scrollbar->GetRange();
782 if ( !range )
783 {
784 thumbStart =
785 thumbEnd = 0;
786 }
787 else
788 {
789 GetScrollBarThumbSize(length,
790 thumbPos,
791 scrollbar->GetThumbSize(),
792 range,
793 &thumbStart,
794 &thumbEnd);
795 }
796
797 if ( elem == wxScrollBar::Element_Thumb )
798 {
799 *start = thumbStart;
800 *width = thumbEnd - thumbStart;
801 }
802 else if ( elem == wxScrollBar::Element_Bar_1 )
803 {
804 *start = 0;
805 *width = thumbStart;
806 }
807 else // elem == wxScrollBar::Element_Bar_2
808 {
809 *start = thumbEnd;
810 *width = length - thumbEnd;
811 }
812
813 // everything is relative to the start of the shaft so far
814 *start += arrow;
815 }
816 break;
817
818 case wxScrollBar::Element_Max:
819 default:
820 wxFAIL_MSG( _T("unknown scrollbar element") );
821 }
822
823 return rect;
824}
825
826wxCoord wxStdRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
827{
828 const wxSize sizeArrowSB = GetScrollbarArrowSize();
829
830 wxCoord sizeArrow, sizeTotal;
831 if ( scrollbar->GetWindowStyle() & wxVERTICAL )
832 {
833 sizeArrow = sizeArrowSB.y;
834 sizeTotal = scrollbar->GetSize().y;
835 }
836 else // horizontal
837 {
838 sizeArrow = sizeArrowSB.x;
839 sizeTotal = scrollbar->GetSize().x;
840 }
841
842 return sizeTotal - 2*sizeArrow;
843}
844
845wxHitTest
846wxStdRenderer::HitTestScrollbar(const wxScrollBar *scrollbar, const wxPoint& pt) const
847{
848 // we only need to work with either x or y coord depending on the
849 // orientation, choose one (but still check the other one to verify if the
850 // mouse is in the window at all)
851 const wxSize sizeArrowSB = GetScrollbarArrowSize();
852
853 wxCoord coord, sizeArrow, sizeTotal;
854 wxSize size = scrollbar->GetSize();
855 if ( scrollbar->GetWindowStyle() & wxVERTICAL )
856 {
857 if ( pt.x < 0 || pt.x > size.x )
858 return wxHT_NOWHERE;
859
860 coord = pt.y;
861 sizeArrow = sizeArrowSB.y;
862 sizeTotal = size.y;
863 }
864 else // horizontal
865 {
866 if ( pt.y < 0 || pt.y > size.y )
867 return wxHT_NOWHERE;
868
869 coord = pt.x;
870 sizeArrow = sizeArrowSB.x;
871 sizeTotal = size.x;
872 }
873
874 // test for the arrows first as it's faster
875 if ( coord < 0 || coord > sizeTotal )
876 {
877 return wxHT_NOWHERE;
878 }
879 else if ( coord < sizeArrow )
880 {
881 return wxHT_SCROLLBAR_ARROW_LINE_1;
882 }
883 else if ( coord > sizeTotal - sizeArrow )
884 {
885 return wxHT_SCROLLBAR_ARROW_LINE_2;
886 }
887 else
888 {
889 // calculate the thumb position in pixels
890 sizeTotal -= 2*sizeArrow;
891 wxCoord thumbStart, thumbEnd;
892 int range = scrollbar->GetRange();
893 if ( !range )
894 {
895 // clicking the scrollbar without range has no effect
896 return wxHT_NOWHERE;
897 }
898 else
899 {
900 GetScrollBarThumbSize(sizeTotal,
901 scrollbar->GetThumbPosition(),
902 scrollbar->GetThumbSize(),
903 range,
904 &thumbStart,
905 &thumbEnd);
906 }
907
908 // now compare with the thumb position
909 coord -= sizeArrow;
910 if ( coord < thumbStart )
911 return wxHT_SCROLLBAR_BAR_1;
912 else if ( coord > thumbEnd )
913 return wxHT_SCROLLBAR_BAR_2;
914 else
915 return wxHT_SCROLLBAR_THUMB;
916 }
917}
918
919
920wxCoord
921wxStdRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar, int thumbPos)
922{
923 int range = scrollbar->GetRange();
924 if ( !range )
925 {
926 // the only valid position anyhow
927 return 0;
928 }
929
930 if ( thumbPos == -1 )
931 {
932 // by default use the current thumb position
933 thumbPos = scrollbar->GetThumbPosition();
934 }
935
936 const wxSize sizeArrow = GetScrollbarArrowSize();
937 return (thumbPos*GetScrollbarSize(scrollbar)) / range
938 + (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x);
939}
940
941int wxStdRenderer::PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord)
942{
943 const wxSize sizeArrow = GetScrollbarArrowSize();
944 return ((coord - (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x)) *
945 scrollbar->GetRange() ) / GetScrollbarSize(scrollbar);
946}
947
948#endif // wxUSE_SCROLLBAR
949
wxWidgets (Impactor)