]> git.saurik.com Git - wxWidgets.git/blob - src/univ/stdrend.cpp
projects / wxWidgets.git / blob
? search:


37f95f7aa7ff4fe7db9cac187f545a4af6a1b713
[wxWidgets.git] / src / univ / stdrend.cpp
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 // constants
34 // ----------------------------------------------------------------------------
35
36 static const int FRAME_BORDER_THICKNESS = 3;
37 static const int RESIZEABLE_FRAME_BORDER_THICKNESS = 4;
38 static const int FRAME_TITLEBAR_HEIGHT = 18;
39 static const int FRAME_BUTTON_WIDTH = 16;
40 static const int FRAME_BUTTON_HEIGHT = 14;
41
42 // ============================================================================
43 // wxStdRenderer implementation
44 // ============================================================================
45
46 // ----------------------------------------------------------------------------
47 // ctor
48 // ----------------------------------------------------------------------------
49
50 wxStdRenderer::wxStdRenderer(const wxColourScheme *scheme)
51 : m_scheme(scheme)
52 {
53 m_penBlack = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_DARK));
54 m_penDarkGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_OUT));
55 m_penLightGrey = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_IN));
56 m_penHighlight = wxPen(wxSCHEME_COLOUR(scheme, SHADOW_HIGHLIGHT));
57
58 m_titlebarFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
59 m_titlebarFont.SetWeight(wxFONTWEIGHT_BOLD);
60 }
61
62 // ----------------------------------------------------------------------------
63 // helper functions
64 // ----------------------------------------------------------------------------
65
66 void
67 wxStdRenderer::DrawSolidRect(wxDC& dc, const wxColour& col, const wxRect& rect)
68 {
69 wxBrush brush(col, wxSOLID);
70 dc.SetBrush(brush);
71 dc.SetPen(*wxTRANSPARENT_PEN);
72 dc.DrawRectangle(rect);
73 }
74
75 void wxStdRenderer::DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen)
76 {
77 // draw
78 dc.SetPen(pen);
79 dc.SetBrush(*wxTRANSPARENT_BRUSH);
80 dc.DrawRectangle(*rect);
81
82 // adjust the rect
83 rect->Inflate(-1);
84 }
85
86 void wxStdRenderer::DrawShadedRect(wxDC& dc, wxRect *rect,
87 const wxPen& pen1, const wxPen& pen2)
88 {
89 // draw the rectangle
90 dc.SetPen(pen1);
91 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
92 rect->GetLeft(), rect->GetBottom());
93 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
94 rect->GetRight(), rect->GetTop());
95 dc.SetPen(pen2);
96 dc.DrawLine(rect->GetRight(), rect->GetTop(),
97 rect->GetRight(), rect->GetBottom());
98 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
99 rect->GetRight() + 1, rect->GetBottom());
100
101 // adjust the rect
102 rect->Inflate(-1);
103 }
104
105 // ----------------------------------------------------------------------------
106 // translate various flags into corresponding renderer constants
107 // ----------------------------------------------------------------------------
108
109 /* static */
110 void wxStdRenderer::GetIndicatorsFromFlags(int flags,
111 IndicatorState& state,
112 IndicatorStatus& status)
113 {
114 if ( flags & wxCONTROL_SELECTED )
115 state = flags & wxCONTROL_DISABLED ? IndicatorState_SelectedDisabled
116 : IndicatorState_Selected;
117 else if ( flags & wxCONTROL_DISABLED )
118 state = IndicatorState_Disabled;
119 else if ( flags & wxCONTROL_PRESSED )
120 state = IndicatorState_Pressed;
121 else
122 state = IndicatorState_Normal;
123
124 status = flags & wxCONTROL_CHECKED ? IndicatorStatus_Checked
125 : flags & wxCONTROL_UNDETERMINED
126 ? IndicatorStatus_Undetermined
127 : IndicatorStatus_Unchecked;
128 }
129
130 /* static */
131 wxStdRenderer::ArrowDirection wxStdRenderer::GetArrowDirection(wxDirection dir)
132 {
133 switch ( dir )
134 {
135 case wxLEFT:
136 return Arrow_Left;
137
138 case wxRIGHT:
139 return Arrow_Right;
140
141 case wxUP:
142 return Arrow_Up;
143
144 case wxDOWN:
145 return Arrow_Down;
146
147 default:
148 wxFAIL_MSG(_T("unknown arrow direction"));
149 }
150
151 return Arrow_Max;
152 }
153
154 // ----------------------------------------------------------------------------
155 // background
156 // ----------------------------------------------------------------------------
157
158 void wxStdRenderer::DrawBackground(wxDC& dc,
159 const wxColour& col,
160 const wxRect& rect,
161 int WXUNUSED(flags),
162 wxWindow *window)
163 {
164 wxColour colBg = col.Ok() ? col
165 : window ? m_scheme->GetBackground(window)
166 : wxSCHEME_COLOUR(m_scheme, CONTROL);
167
168 DrawSolidRect(dc, colBg, rect);
169 }
170
171
172 void wxStdRenderer::DrawButtonSurface(wxDC& dc,
173 const wxColour& col,
174 const wxRect& rect,
175 int flags)
176 {
177 DrawBackground(dc, col, rect, flags);
178 }
179
180 // ----------------------------------------------------------------------------
181 // text
182 // ----------------------------------------------------------------------------
183
184 void wxStdRenderer::DrawFocusRect(wxDC& dc, const wxRect& rect)
185 {
186 // draw the pixels manually because the "dots" in wxPen with wxDOT style
187 // may be short traits and not really dots
188 //
189 // note that to behave in the same manner as DrawRect(), we must exclude
190 // the bottom and right borders from the rectangle
191 wxCoord x1 = rect.GetLeft(),
192 y1 = rect.GetTop(),
193 x2 = rect.GetRight(),
194 y2 = rect.GetBottom();
195
196 dc.SetPen(m_penBlack);
197
198 // this seems to be closer than what Windows does than wxINVERT although
199 // I'm still not sure if it's correct
200 dc.SetLogicalFunction(wxAND_REVERSE);
201
202 wxCoord z;
203 for ( z = x1 + 1; z < x2; z += 2 )
204 dc.DrawPoint(z, rect.GetTop());
205
206 wxCoord shift = z == x2 ? 0 : 1;
207 for ( z = y1 + shift; z < y2; z += 2 )
208 dc.DrawPoint(x2, z);
209
210 shift = z == y2 ? 0 : 1;
211 for ( z = x2 - shift; z > x1; z -= 2 )
212 dc.DrawPoint(z, y2);
213
214 shift = z == x1 ? 0 : 1;
215 for ( z = y2 - shift; z > y1; z -= 2 )
216 dc.DrawPoint(x1, z);
217
218 dc.SetLogicalFunction(wxCOPY);
219 }
220
221 void wxStdRenderer::DrawLabel(wxDC& dc,
222 const wxString& label,
223 const wxRect& rect,
224 int flags,
225 int alignment,
226 int indexAccel,
227 wxRect *rectBounds)
228 {
229 DrawButtonLabel(dc, label, wxNullBitmap, rect, flags,
230 alignment, indexAccel, rectBounds);
231 }
232
233 void wxStdRenderer::DrawButtonLabel(wxDC& dc,
234 const wxString& label,
235 const wxBitmap& image,
236 const wxRect& rect,
237 int flags,
238 int alignment,
239 int indexAccel,
240 wxRect *rectBounds)
241 {
242 wxRect rectLabel = rect;
243 if ( !label.empty() && (flags & wxCONTROL_DISABLED) )
244 {
245 if ( flags & wxCONTROL_PRESSED )
246 {
247 // shift the label if a button is pressed
248 rectLabel.Offset(1, 1);
249 }
250
251 // draw shadow of the text
252 dc.SetTextForeground(m_penHighlight.GetColour());
253 wxRect rectShadow = rect;
254 rectShadow.Offset(1, 1);
255 dc.DrawLabel(label, rectShadow, alignment, indexAccel);
256
257 // make the main label text grey
258 dc.SetTextForeground(m_penDarkGrey.GetColour());
259
260 if ( flags & wxCONTROL_FOCUSED )
261 {
262 // leave enough space for the focus rect
263 rectLabel.Inflate(-2);
264 }
265 }
266
267 dc.DrawLabel(label, image, rectLabel, alignment, indexAccel, rectBounds);
268
269 if ( !label.empty() && (flags & wxCONTROL_FOCUSED) )
270 {
271 rectLabel.Inflate(-1);
272
273 DrawFocusRect(dc, rectLabel);
274 }
275 }
276
277 // ----------------------------------------------------------------------------
278 // borders
279 // ----------------------------------------------------------------------------
280
281 /*
282 We implement standard-looking 3D borders which have the following appearance:
283
284 The raised border:
285
286 WWWWWWWWWWWWWWWWWWWWWWB
287 WHHHHHHHHHHHHHHHHHHHHGB
288 WH GB W = white (HILIGHT)
289 WH GB H = light grey (LIGHT)
290 WH GB G = dark grey (SHADOI)
291 WH GB B = black (DKSHADOI)
292 WH GB
293 WH GB
294 WGGGGGGGGGGGGGGGGGGGGGB
295 BBBBBBBBBBBBBBBBBBBBBBB
296
297 The sunken border looks like this:
298
299 GGGGGGGGGGGGGGGGGGGGGGW
300 GBBBBBBBBBBBBBBBBBBBBHW
301 GB HW
302 GB HW
303 GB HW
304 GB HW
305 GB HW
306 GB HW
307 GHHHHHHHHHHHHHHHHHHHHHW
308 WWWWWWWWWWWWWWWWWWWWWWW
309
310 The static border (used for the controls which don't get focus) is like
311 this:
312
313 GGGGGGGGGGGGGGGGGGGGGGW
314 G W
315 G W
316 G W
317 G W
318 G W
319 G W
320 G W
321 WWWWWWWWWWWWWWWWWWWWWWW
322
323 The most complicated is the double border which is a combination of special
324 "anti-sunken" border and an extra border inside it:
325
326 HHHHHHHHHHHHHHHHHHHHHHB
327 HWWWWWWWWWWWWWWWWWWWWGB
328 HWHHHHHHHHHHHHHHHHHHHGB
329 HWH HGB
330 HWH HGB
331 HWH HGB
332 HWH HGB
333 HWHHHHHHHHHHHHHHHHHHHGB
334 HGGGGGGGGGGGGGGGGGGGGGB
335 BBBBBBBBBBBBBBBBBBBBBBB
336
337 And the simple border is, well, simple:
338
339 BBBBBBBBBBBBBBBBBBBBBBB
340 B B
341 B B
342 B B
343 B B
344 B B
345 B B
346 B B
347 B B
348 BBBBBBBBBBBBBBBBBBBBBBB
349 */
350
351 void wxStdRenderer::DrawRaisedBorder(wxDC& dc, wxRect *rect)
352 {
353 DrawShadedRect(dc, rect, m_penHighlight, m_penBlack);
354 DrawShadedRect(dc, rect, m_penLightGrey, m_penDarkGrey);
355 }
356
357 void wxStdRenderer::DrawSunkenBorder(wxDC& dc, wxRect *rect)
358 {
359 DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
360 DrawShadedRect(dc, rect, m_penBlack, m_penLightGrey);
361 }
362
363 void wxStdRenderer::DrawAntiSunkenBorder(wxDC& dc, wxRect *rect)
364 {
365 DrawShadedRect(dc, rect, m_penLightGrey, m_penBlack);
366 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
367 }
368
369 void wxStdRenderer::DrawFrameBorder(wxDC& dc, wxRect *rect)
370 {
371 DrawShadedRect(dc, rect, m_penDarkGrey, m_penHighlight);
372 DrawShadedRect(dc, rect, m_penHighlight, m_penDarkGrey);
373 }
374
375 void wxStdRenderer::DrawBorder(wxDC& dc,
376 wxBorder border,
377 const wxRect& rectTotal,
378 int WXUNUSED(flags),
379 wxRect *rectIn)
380 {
381 wxRect rect = rectTotal;
382
383 switch ( border )
384 {
385 case wxBORDER_SUNKEN:
386 DrawSunkenBorder(dc, &rect);
387 break;
388
389 case wxBORDER_DOUBLE:
390 DrawAntiSunkenBorder(dc, &rect);
391 DrawRect(dc, &rect, m_penLightGrey);
392 break;
393
394 case wxBORDER_STATIC:
395 DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
396 break;
397
398 case wxBORDER_RAISED:
399 DrawRaisedBorder(dc, &rect);
400 break;
401
402 case wxBORDER_SIMPLE:
403 DrawRect(dc, &rect, m_penBlack);
404 break;
405
406 default:
407 wxFAIL_MSG(_T("unknown border type"));
408 // fall through
409
410 case wxBORDER_DEFAULT:
411 case wxBORDER_NONE:
412 break;
413 }
414
415 if ( rectIn )
416 *rectIn = rect;
417 }
418
419 wxRect wxStdRenderer::GetBorderDimensions(wxBorder border) const
420 {
421 wxCoord width;
422 switch ( border )
423 {
424 case wxBORDER_SIMPLE:
425 case wxBORDER_STATIC:
426 width = 1;
427 break;
428
429 case wxBORDER_RAISED:
430 case wxBORDER_SUNKEN:
431 width = 2;
432 break;
433
434 case wxBORDER_DOUBLE:
435 width = 3;
436 break;
437
438 default:
439 wxFAIL_MSG(_T("unknown border type"));
440 // fall through
441
442 case wxBORDER_DEFAULT:
443 case wxBORDER_NONE:
444 width = 0;
445 break;
446 }
447
448 wxRect rect;
449 rect.x =
450 rect.y =
451 rect.width =
452 rect.height = width;
453
454 return rect;
455 }
456
457 void wxStdRenderer::AdjustSize(wxSize *size, const wxWindow *window)
458 {
459 // take into account the border width
460 wxRect rectBorder = GetBorderDimensions(window->GetBorder());
461 size->x += rectBorder.x + rectBorder.width;
462 size->y += rectBorder.y + rectBorder.height;
463 }
464
465 bool wxStdRenderer::AreScrollbarsInsideBorder() const
466 {
467 return false;
468 }
469
470 wxCoord wxStdRenderer::GetListboxItemHeight(wxCoord fontHeight)
471 {
472 return fontHeight + 2;
473 }
474
475 void wxStdRenderer::DrawTextBorder(wxDC& dc,
476 wxBorder border,
477 const wxRect& rect,
478 int flags,
479 wxRect *rectIn)
480 {
481 DrawBorder(dc, border, rect, flags, rectIn);
482 }
483
484 // ----------------------------------------------------------------------------
485 // lines and boxes
486 // ----------------------------------------------------------------------------
487
488 void
489 wxStdRenderer::DrawHorizontalLine(wxDC& dc, wxCoord y, wxCoord x1, wxCoord x2)
490 {
491 dc.SetPen(m_penDarkGrey);
492 dc.DrawLine(x1, y, x2 + 1, y);
493
494 dc.SetPen(m_penHighlight);
495 y++;
496 dc.DrawLine(x1, y, x2 + 1, y);
497 }
498
499 void
500 wxStdRenderer::DrawVerticalLine(wxDC& dc, wxCoord x, wxCoord y1, wxCoord y2)
501 {
502 dc.SetPen(m_penDarkGrey);
503 dc.DrawLine(x, y1, x, y2 + 1);
504
505 dc.SetPen(m_penHighlight);
506 x++;
507 dc.DrawLine(x, y1, x, y2 + 1);
508 }
509
510 void wxStdRenderer::DrawFrameWithoutLabel(wxDC& dc,
511 const wxRect& rectFrame,
512 const wxRect& rectLabel)
513 {
514 // draw left, bottom and right lines entirely
515 DrawVerticalLine(dc, rectFrame.GetLeft(),
516 rectFrame.GetTop(), rectFrame.GetBottom() - 2);
517 DrawHorizontalLine(dc, rectFrame.GetBottom() - 1,
518 rectFrame.GetLeft(), rectFrame.GetRight());
519 DrawVerticalLine(dc, rectFrame.GetRight() - 1,
520 rectFrame.GetTop(), rectFrame.GetBottom() - 1);
521
522 // and 2 parts of the top line
523 DrawHorizontalLine(dc, rectFrame.GetTop(),
524 rectFrame.GetLeft() + 1, rectLabel.GetLeft());
525 DrawHorizontalLine(dc, rectFrame.GetTop(),
526 rectLabel.GetRight(), rectFrame.GetRight() - 2);
527 }
528
529 void wxStdRenderer::DrawFrameWithLabel(wxDC& dc,
530 const wxString& label,
531 const wxRect& rectFrame,
532 const wxRect& rectText,
533 int flags,
534 int alignment,
535 int indexAccel)
536 {
537 wxRect rectLabel;
538 DrawLabel(dc, label, rectText, flags, alignment, indexAccel, &rectLabel);
539
540 DrawFrameWithoutLabel(dc, rectFrame, rectLabel);
541 }
542
543 void wxStdRenderer::DrawFrame(wxDC& dc,
544 const wxString& label,
545 const wxRect& rect,
546 int flags,
547 int alignment,
548 int indexAccel)
549 {
550 wxCoord height = 0; // of the label
551 wxRect rectFrame = rect;
552 if ( !label.empty() )
553 {
554 // the text should touch the top border of the rect, so the frame
555 // itself should be lower
556 dc.GetTextExtent(label, NULL, &height);
557 rectFrame.y += height / 2;
558 rectFrame.height -= height / 2;
559
560 // we have to draw each part of the frame individually as we can't
561 // erase the background beyond the label as it might contain some
562 // pixmap already, so drawing everything and then overwriting part of
563 // the frame with label doesn't work
564
565 // TODO: the +5 shouldn't be hard coded
566 wxRect rectText;
567 rectText.x = rectFrame.x + 5;
568 rectText.y = rect.y;
569 rectText.width = rectFrame.width - 7; // +2 border width
570 rectText.height = height;
571
572 DrawFrameWithLabel(dc, label, rectFrame, rectText, flags,
573 alignment, indexAccel);
574 }
575 else // no label
576 {
577 DrawFrameBorder(dc, &rectFrame);
578 }
579 }
580
581 void wxStdRenderer::DrawItem(wxDC& dc,
582 const wxString& label,
583 const wxRect& rect,
584 int flags)
585 {
586 wxDCTextColourChanger colChanger(dc);
587
588 if ( flags & wxCONTROL_SELECTED )
589 {
590 colChanger.Set(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
591
592 const wxColour colBg = wxSCHEME_COLOUR(m_scheme, HIGHLIGHT);
593 dc.SetBrush(colBg);
594 dc.SetPen(colBg);
595 dc.DrawRectangle(rect);
596 }
597
598 wxRect rectText = rect;
599 rectText.x += 2;
600 rectText.width -= 2;
601 dc.DrawLabel(label, wxNullBitmap, rectText);
602
603 if ( flags & wxCONTROL_FOCUSED )
604 {
605 DrawFocusRect(dc, rect);
606 }
607 }
608
609 void wxStdRenderer::DrawCheckItemBitmap(wxDC& dc,
610 const wxBitmap& bitmap,
611 const wxRect& rect,
612 int flags)
613 {
614 DrawCheckButton(dc, wxEmptyString, bitmap, rect, flags);
615 }
616
617 void wxStdRenderer::DrawCheckItem(wxDC& dc,
618 const wxString& label,
619 const wxBitmap& bitmap,
620 const wxRect& rect,
621 int flags)
622 {
623 wxRect rectBitmap = rect;
624 rectBitmap.width = GetCheckBitmapSize().x;
625 DrawCheckItemBitmap(dc, bitmap, rectBitmap, flags);
626
627 wxRect rectLabel = rect;
628 wxCoord shift = rectBitmap.width + 2*GetCheckItemMargin();
629 rectLabel.x += shift;
630 rectLabel.width -= shift;
631 DrawItem(dc, label, rectLabel, flags);
632 }
633
634 // ----------------------------------------------------------------------------
635 // check and radio bitmaps
636 // ----------------------------------------------------------------------------
637
638 void wxStdRenderer::DrawCheckButton(wxDC& dc,
639 const wxString& label,
640 const wxBitmap& bitmap,
641 const wxRect& rect,
642 int flags,
643 wxAlignment align,
644 int indexAccel)
645 {
646 wxBitmap bmp(bitmap.Ok() ? bitmap : GetCheckBitmap(flags));
647
648 DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
649 }
650
651 void wxStdRenderer::DrawRadioButton(wxDC& dc,
652 const wxString& label,
653 const wxBitmap& bitmap,
654 const wxRect& rect,
655 int flags,
656 wxAlignment align,
657 int indexAccel)
658 {
659 wxBitmap bmp(bitmap.Ok() ? bitmap : GetRadioBitmap(flags));
660
661 DrawCheckOrRadioButton(dc, label, bmp, rect, flags, align, indexAccel);
662 }
663
664 void wxStdRenderer::DrawCheckOrRadioButton(wxDC& dc,
665 const wxString& label,
666 const wxBitmap& bitmap,
667 const wxRect& rect,
668 int flags,
669 wxAlignment align,
670 int indexAccel)
671 {
672 // calculate the position of the bitmap and of the label
673 wxCoord heightBmp = bitmap.GetHeight();
674 wxCoord xBmp,
675 yBmp = rect.y + (rect.height - heightBmp) / 2;
676
677 wxRect rectLabel;
678 dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height);
679 rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2;
680
681 // align label vertically with the bitmap - looks nicer like this
682 rectLabel.y -= (rectLabel.height - heightBmp) % 2;
683
684 // calc horz position
685 if ( align == wxALIGN_RIGHT )
686 {
687 xBmp = rect.GetRight() - bitmap.GetWidth();
688 rectLabel.x = rect.x + 3;
689 rectLabel.SetRight(xBmp);
690 }
691 else // normal (checkbox to the left of the text) case
692 {
693 xBmp = rect.x;
694 rectLabel.x = xBmp + bitmap.GetWidth() + 5;
695 rectLabel.SetRight(rect.GetRight());
696 }
697
698 dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */);
699
700 DrawLabel(dc, label, rectLabel, flags,
701 wxALIGN_LEFT | wxALIGN_TOP, indexAccel);
702 }
703
704 #if wxUSE_TEXTCTRL
705
706 void wxStdRenderer::DrawTextLine(wxDC& dc,
707 const wxString& text,
708 const wxRect& rect,
709 int selStart,
710 int selEnd,
711 int flags)
712 {
713 if ( (selStart == -1) || !(flags & wxCONTROL_FOCUSED) )
714 {
715 // just draw it as is
716 dc.DrawText(text, rect.x, rect.y);
717 }
718 else // we have selection
719 {
720 wxCoord width,
721 x = rect.x;
722
723 // draw the part before selection
724 wxString s(text, (size_t)selStart);
725 if ( !s.empty() )
726 {
727 dc.DrawText(s, x, rect.y);
728
729 dc.GetTextExtent(s, &width, NULL);
730 x += width;
731 }
732
733 // draw the selection itself
734 s = wxString(text.c_str() + selStart, text.c_str() + selEnd);
735 if ( !s.empty() )
736 {
737 wxColour colFg = dc.GetTextForeground(),
738 colBg = dc.GetTextBackground();
739 dc.SetTextForeground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT_TEXT));
740 dc.SetTextBackground(wxSCHEME_COLOUR(m_scheme, HIGHLIGHT));
741 dc.SetBackgroundMode(wxSOLID);
742
743 dc.DrawText(s, x, rect.y);
744 dc.GetTextExtent(s, &width, NULL);
745 x += width;
746
747 dc.SetBackgroundMode(wxTRANSPARENT);
748 dc.SetTextBackground(colBg);
749 dc.SetTextForeground(colFg);
750 }
751
752 // draw the final part
753 s = text.c_str() + selEnd;
754 if ( !s.empty() )
755 {
756 dc.DrawText(s, x, rect.y);
757 }
758 }
759 }
760
761 void wxStdRenderer::DrawLineWrapMark(wxDC& WXUNUSED(dc),
762 const wxRect& WXUNUSED(rect))
763 {
764 // nothing by default
765 }
766
767 int wxStdRenderer::GetTextBorderWidth(const wxTextCtrl * WXUNUSED(text)) const
768 {
769 return 1;
770 }
771
772 wxRect
773 wxStdRenderer::GetTextTotalArea(const wxTextCtrl *text, const wxRect& rect) const
774 {
775 wxRect rectTotal = rect;
776 rectTotal.Inflate(GetTextBorderWidth(text));
777 return rectTotal;
778 }
779
780 wxRect wxStdRenderer::GetTextClientArea(const wxTextCtrl *text,
781 const wxRect& rect,
782 wxCoord *extraSpaceBeyond) const
783 {
784 wxRect rectText = rect;
785 rectText.Deflate(GetTextBorderWidth(text));
786
787 if ( extraSpaceBeyond )
788 *extraSpaceBeyond = 0;
789
790 return rectText;
791 }
792
793 #endif // wxUSE_TEXTCTRL
794
795 // ----------------------------------------------------------------------------
796 // scrollbars drawing
797 // ----------------------------------------------------------------------------
798
799 void wxStdRenderer::DrawScrollbarArrow(wxDC& dc,
800 wxDirection dir,
801 const wxRect& rect,
802 int flags)
803 {
804 DrawArrow(dc, dir, rect, flags);
805 }
806
807 void wxStdRenderer::DrawScrollCorner(wxDC& dc, const wxRect& rect)
808 {
809 DrawSolidRect(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rect);
810 }
811
812 // ----------------------------------------------------------------------------
813 // scrollbars geometry
814 // ----------------------------------------------------------------------------
815
816 #if wxUSE_SCROLLBAR
817
818 /* static */
819 void wxStdRenderer::GetScrollBarThumbSize(wxCoord length,
820 int thumbPos,
821 int thumbSize,
822 int range,
823 wxCoord *thumbStart,
824 wxCoord *thumbEnd)
825 {
826 // the thumb can't be made less than this number of pixels
827 static const wxCoord thumbMinWidth = 8; // FIXME: should be configurable
828
829 *thumbStart = (length*thumbPos) / range;
830 *thumbEnd = (length*(thumbPos + thumbSize)) / range;
831
832 if ( *thumbEnd - *thumbStart < thumbMinWidth )
833 {
834 // adjust the end if possible
835 if ( *thumbStart <= length - thumbMinWidth )
836 {
837 // yes, just make it wider
838 *thumbEnd = *thumbStart + thumbMinWidth;
839 }
840 else // it is at the bottom of the scrollbar
841 {
842 // so move it a bit up
843 *thumbStart = length - thumbMinWidth;
844 *thumbEnd = length;
845 }
846 }
847 }
848
849 wxRect wxStdRenderer::GetScrollbarRect(const wxScrollBar *scrollbar,
850 wxScrollBar::Element elem,
851 int thumbPos) const
852 {
853 if ( thumbPos == -1 )
854 {
855 thumbPos = scrollbar->GetThumbPosition();
856 }
857
858 const wxSize sizeArrow = GetScrollbarArrowSize();
859
860 wxSize sizeTotal = scrollbar->GetClientSize();
861 wxCoord *start, *width;
862 wxCoord length, arrow;
863 wxRect rect;
864 if ( scrollbar->IsVertical() )
865 {
866 rect.x = 0;
867 rect.width = sizeTotal.x;
868 length = sizeTotal.y;
869 start = &rect.y;
870 width = &rect.height;
871 arrow = sizeArrow.y;
872 }
873 else // horizontal
874 {
875 rect.y = 0;
876 rect.height = sizeTotal.y;
877 length = sizeTotal.x;
878 start = &rect.x;
879 width = &rect.width;
880 arrow = sizeArrow.x;
881 }
882
883 switch ( elem )
884 {
885 case wxScrollBar::Element_Arrow_Line_1:
886 *start = 0;
887 *width = arrow;
888 break;
889
890 case wxScrollBar::Element_Arrow_Line_2:
891 *start = length - arrow;
892 *width = arrow;
893 break;
894
895 case wxScrollBar::Element_Arrow_Page_1:
896 case wxScrollBar::Element_Arrow_Page_2:
897 // we don't have them at all
898 break;
899
900 case wxScrollBar::Element_Thumb:
901 case wxScrollBar::Element_Bar_1:
902 case wxScrollBar::Element_Bar_2:
903 // we need to calculate the thumb position - do it
904 {
905 length -= 2*arrow;
906 wxCoord thumbStart, thumbEnd;
907 int range = scrollbar->GetRange();
908 if ( !range )
909 {
910 thumbStart =
911 thumbEnd = 0;
912 }
913 else
914 {
915 GetScrollBarThumbSize(length,
916 thumbPos,
917 scrollbar->GetThumbSize(),
918 range,
919 &thumbStart,
920 &thumbEnd);
921 }
922
923 if ( elem == wxScrollBar::Element_Thumb )
924 {
925 *start = thumbStart;
926 *width = thumbEnd - thumbStart;
927 }
928 else if ( elem == wxScrollBar::Element_Bar_1 )
929 {
930 *start = 0;
931 *width = thumbStart;
932 }
933 else // elem == wxScrollBar::Element_Bar_2
934 {
935 *start = thumbEnd;
936 *width = length - thumbEnd;
937 }
938
939 // everything is relative to the start of the shaft so far
940 *start += arrow;
941 }
942 break;
943
944 case wxScrollBar::Element_Max:
945 default:
946 wxFAIL_MSG( _T("unknown scrollbar element") );
947 }
948
949 return rect;
950 }
951
952 wxCoord wxStdRenderer::GetScrollbarSize(const wxScrollBar *scrollbar)
953 {
954 const wxSize sizeArrowSB = GetScrollbarArrowSize();
955
956 wxCoord sizeArrow, sizeTotal;
957 if ( scrollbar->GetWindowStyle() & wxVERTICAL )
958 {
959 sizeArrow = sizeArrowSB.y;
960 sizeTotal = scrollbar->GetSize().y;
961 }
962 else // horizontal
963 {
964 sizeArrow = sizeArrowSB.x;
965 sizeTotal = scrollbar->GetSize().x;
966 }
967
968 return sizeTotal - 2*sizeArrow;
969 }
970
971 wxHitTest
972 wxStdRenderer::HitTestScrollbar(const wxScrollBar *scrollbar, const wxPoint& pt) const
973 {
974 // we only need to work with either x or y coord depending on the
975 // orientation, choose one (but still check the other one to verify if the
976 // mouse is in the window at all)
977 const wxSize sizeArrowSB = GetScrollbarArrowSize();
978
979 wxCoord coord, sizeArrow, sizeTotal;
980 wxSize size = scrollbar->GetSize();
981 if ( scrollbar->GetWindowStyle() & wxVERTICAL )
982 {
983 if ( pt.x < 0 || pt.x > size.x )
984 return wxHT_NOWHERE;
985
986 coord = pt.y;
987 sizeArrow = sizeArrowSB.y;
988 sizeTotal = size.y;
989 }
990 else // horizontal
991 {
992 if ( pt.y < 0 || pt.y > size.y )
993 return wxHT_NOWHERE;
994
995 coord = pt.x;
996 sizeArrow = sizeArrowSB.x;
997 sizeTotal = size.x;
998 }
999
1000 // test for the arrows first as it's faster
1001 if ( coord < 0 || coord > sizeTotal )
1002 {
1003 return wxHT_NOWHERE;
1004 }
1005 else if ( coord < sizeArrow )
1006 {
1007 return wxHT_SCROLLBAR_ARROW_LINE_1;
1008 }
1009 else if ( coord > sizeTotal - sizeArrow )
1010 {
1011 return wxHT_SCROLLBAR_ARROW_LINE_2;
1012 }
1013 else
1014 {
1015 // calculate the thumb position in pixels
1016 sizeTotal -= 2*sizeArrow;
1017 wxCoord thumbStart, thumbEnd;
1018 int range = scrollbar->GetRange();
1019 if ( !range )
1020 {
1021 // clicking the scrollbar without range has no effect
1022 return wxHT_NOWHERE;
1023 }
1024 else
1025 {
1026 GetScrollBarThumbSize(sizeTotal,
1027 scrollbar->GetThumbPosition(),
1028 scrollbar->GetThumbSize(),
1029 range,
1030 &thumbStart,
1031 &thumbEnd);
1032 }
1033
1034 // now compare with the thumb position
1035 coord -= sizeArrow;
1036 if ( coord < thumbStart )
1037 return wxHT_SCROLLBAR_BAR_1;
1038 else if ( coord > thumbEnd )
1039 return wxHT_SCROLLBAR_BAR_2;
1040 else
1041 return wxHT_SCROLLBAR_THUMB;
1042 }
1043 }
1044
1045
1046 wxCoord
1047 wxStdRenderer::ScrollbarToPixel(const wxScrollBar *scrollbar, int thumbPos)
1048 {
1049 int range = scrollbar->GetRange();
1050 if ( !range )
1051 {
1052 // the only valid position anyhow
1053 return 0;
1054 }
1055
1056 if ( thumbPos == -1 )
1057 {
1058 // by default use the current thumb position
1059 thumbPos = scrollbar->GetThumbPosition();
1060 }
1061
1062 const wxSize sizeArrow = GetScrollbarArrowSize();
1063 return (thumbPos*GetScrollbarSize(scrollbar)) / range
1064 + (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x);
1065 }
1066
1067 int wxStdRenderer::PixelToScrollbar(const wxScrollBar *scrollbar, wxCoord coord)
1068 {
1069 const wxSize sizeArrow = GetScrollbarArrowSize();
1070 return ((coord - (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x)) *
1071 scrollbar->GetRange() ) / GetScrollbarSize(scrollbar);
1072 }
1073
1074 #endif // wxUSE_SCROLLBAR
1075
1076 // ----------------------------------------------------------------------------
1077 // status bar
1078 // ----------------------------------------------------------------------------
1079
1080 #if wxUSE_STATUSBAR
1081
1082 wxSize wxStdRenderer::GetStatusBarBorders(wxCoord *borderBetweenFields) const
1083 {
1084 if ( borderBetweenFields )
1085 *borderBetweenFields = 2;
1086
1087 return wxSize(2, 2);
1088 }
1089
1090 void wxStdRenderer::DrawStatusField(wxDC& dc,
1091 const wxRect& rect,
1092 const wxString& label,
1093 int flags,
1094 int style)
1095 {
1096 wxRect rectIn;
1097
1098 if ( style == wxSB_RAISED )
1099 DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
1100 else if ( style != wxSB_FLAT )
1101 DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
1102
1103 rectIn.Deflate(GetStatusBarBorders(NULL));
1104
1105 wxDCClipper clipper(dc, rectIn);
1106 DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
1107 }
1108
1109 #endif // wxUSE_STATUSBAR
1110
1111 // ----------------------------------------------------------------------------
1112 // top level windows
1113 // ----------------------------------------------------------------------------
1114
1115 int wxStdRenderer::HitTestFrame(const wxRect& rect, const wxPoint& pt, int flags) const
1116 {
1117 wxRect client = GetFrameClientArea(rect, flags);
1118
1119 if ( client.Contains(pt) )
1120 return wxHT_TOPLEVEL_CLIENT_AREA;
1121
1122 if ( flags & wxTOPLEVEL_TITLEBAR )
1123 {
1124 wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
1125
1126 if ( flags & wxTOPLEVEL_ICON )
1127 {
1128 if ( wxRect(client.GetPosition(), GetFrameIconSize()).Contains(pt) )
1129 return wxHT_TOPLEVEL_ICON;
1130 }
1131
1132 wxRect btnRect(client.GetRight() - 2 - FRAME_BUTTON_WIDTH,
1133 client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2,
1134 FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
1135
1136 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
1137 {
1138 if ( btnRect.Contains(pt) )
1139 return wxHT_TOPLEVEL_BUTTON_CLOSE;
1140 btnRect.x -= FRAME_BUTTON_WIDTH + 2;
1141 }
1142 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
1143 {
1144 if ( btnRect.Contains(pt) )
1145 return wxHT_TOPLEVEL_BUTTON_MAXIMIZE;
1146 btnRect.x -= FRAME_BUTTON_WIDTH;
1147 }
1148 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
1149 {
1150 if ( btnRect.Contains(pt) )
1151 return wxHT_TOPLEVEL_BUTTON_RESTORE;
1152 btnRect.x -= FRAME_BUTTON_WIDTH;
1153 }
1154 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
1155 {
1156 if ( btnRect.Contains(pt) )
1157 return wxHT_TOPLEVEL_BUTTON_ICONIZE;
1158 btnRect.x -= FRAME_BUTTON_WIDTH;
1159 }
1160 if ( flags & wxTOPLEVEL_BUTTON_HELP )
1161 {
1162 if ( btnRect.Contains(pt) )
1163 return wxHT_TOPLEVEL_BUTTON_HELP;
1164 btnRect.x -= FRAME_BUTTON_WIDTH;
1165 }
1166
1167 if ( pt.y >= client.y && pt.y < client.y + FRAME_TITLEBAR_HEIGHT )
1168 return wxHT_TOPLEVEL_TITLEBAR;
1169 }
1170
1171 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
1172 {
1173 // we are certainly at one of borders, let's decide which one:
1174
1175 int border = 0;
1176 // dirty trick, relies on the way wxHT_TOPLEVEL_XXX are defined!
1177 if ( pt.x < client.x )
1178 border |= wxHT_TOPLEVEL_BORDER_W;
1179 else if ( pt.x >= client.width + client.x )
1180 border |= wxHT_TOPLEVEL_BORDER_E;
1181 if ( pt.y < client.y )
1182 border |= wxHT_TOPLEVEL_BORDER_N;
1183 else if ( pt.y >= client.height + client.y )
1184 border |= wxHT_TOPLEVEL_BORDER_S;
1185 return border;
1186 }
1187
1188 return wxHT_NOWHERE;
1189 }
1190
1191 void wxStdRenderer::DrawFrameTitleBar(wxDC& dc,
1192 const wxRect& rect,
1193 const wxString& title,
1194 const wxIcon& icon,
1195 int flags,
1196 int specialButton,
1197 int specialButtonFlags)
1198 {
1199 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
1200 {
1201 DrawFrameBorder(dc, rect, flags);
1202 }
1203 if ( flags & wxTOPLEVEL_TITLEBAR )
1204 {
1205 DrawFrameBackground(dc, rect, flags);
1206 if ( flags & wxTOPLEVEL_ICON )
1207 DrawFrameIcon(dc, rect, icon, flags);
1208 DrawFrameTitle(dc, rect, title, flags);
1209
1210 wxRect client = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
1211 wxCoord x,y;
1212 x = client.GetRight() - 2 - FRAME_BUTTON_WIDTH;
1213 y = client.GetTop() + (FRAME_TITLEBAR_HEIGHT-FRAME_BUTTON_HEIGHT)/2;
1214
1215 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
1216 {
1217 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_CLOSE,
1218 (specialButton == wxTOPLEVEL_BUTTON_CLOSE) ?
1219 specialButtonFlags : 0);
1220 x -= FRAME_BUTTON_WIDTH + 2;
1221 }
1222 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
1223 {
1224 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_MAXIMIZE,
1225 (specialButton == wxTOPLEVEL_BUTTON_MAXIMIZE) ?
1226 specialButtonFlags : 0);
1227 x -= FRAME_BUTTON_WIDTH;
1228 }
1229 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
1230 {
1231 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_RESTORE,
1232 (specialButton == wxTOPLEVEL_BUTTON_RESTORE) ?
1233 specialButtonFlags : 0);
1234 x -= FRAME_BUTTON_WIDTH;
1235 }
1236 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
1237 {
1238 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_ICONIZE,
1239 (specialButton == wxTOPLEVEL_BUTTON_ICONIZE) ?
1240 specialButtonFlags : 0);
1241 x -= FRAME_BUTTON_WIDTH;
1242 }
1243 if ( flags & wxTOPLEVEL_BUTTON_HELP )
1244 {
1245 DrawFrameButton(dc, x, y, wxTOPLEVEL_BUTTON_HELP,
1246 (specialButton == wxTOPLEVEL_BUTTON_HELP) ?
1247 specialButtonFlags : 0);
1248 }
1249 }
1250 }
1251
1252 void wxStdRenderer::DrawFrameBorder(wxDC& dc, const wxRect& rect, int flags)
1253 {
1254 if ( !(flags & wxTOPLEVEL_BORDER) )
1255 return;
1256
1257 wxRect r(rect);
1258
1259 DrawShadedRect(dc, &r, m_penLightGrey, m_penBlack);
1260 DrawShadedRect(dc, &r, m_penHighlight, m_penDarkGrey);
1261 DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
1262 if ( flags & wxTOPLEVEL_RESIZEABLE )
1263 DrawShadedRect(dc, &r, m_penLightGrey, m_penLightGrey);
1264 }
1265
1266 void wxStdRenderer::DrawFrameBackground(wxDC& dc, const wxRect& rect, int flags)
1267 {
1268 if ( !(flags & wxTOPLEVEL_TITLEBAR) )
1269 return;
1270
1271 wxColour col = m_scheme->Get(flags & wxTOPLEVEL_ACTIVE
1272 ? wxColourScheme::TITLEBAR_ACTIVE
1273 : wxColourScheme::TITLEBAR);
1274
1275 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
1276 r.height = FRAME_TITLEBAR_HEIGHT;
1277
1278 DrawBackground(dc, col, r);
1279 }
1280
1281 void wxStdRenderer::DrawFrameTitle(wxDC& dc,
1282 const wxRect& rect,
1283 const wxString& title,
1284 int flags)
1285 {
1286 wxColour col = m_scheme->Get(flags & wxTOPLEVEL_ACTIVE
1287 ? wxColourScheme::TITLEBAR_ACTIVE_TEXT
1288 : wxColourScheme::TITLEBAR_TEXT);
1289 dc.SetTextForeground(col);
1290
1291 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
1292 r.height = FRAME_TITLEBAR_HEIGHT;
1293 if ( flags & wxTOPLEVEL_ICON )
1294 {
1295 r.x += FRAME_TITLEBAR_HEIGHT;
1296 r.width -= FRAME_TITLEBAR_HEIGHT + 2;
1297 }
1298 else
1299 {
1300 r.x += 1;
1301 r.width -= 3;
1302 }
1303
1304 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
1305 r.width -= FRAME_BUTTON_WIDTH + 2;
1306 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
1307 r.width -= FRAME_BUTTON_WIDTH;
1308 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
1309 r.width -= FRAME_BUTTON_WIDTH;
1310 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
1311 r.width -= FRAME_BUTTON_WIDTH;
1312 if ( flags & wxTOPLEVEL_BUTTON_HELP )
1313 r.width -= FRAME_BUTTON_WIDTH;
1314
1315 dc.SetFont(m_titlebarFont);
1316
1317 wxString s;
1318 wxCoord textW;
1319 dc.GetTextExtent(title, &textW, NULL);
1320 if ( textW > r.width )
1321 {
1322 // text is too big, let's shorten it and add "..." after it:
1323 size_t len = title.length();
1324 wxCoord WSoFar, letterW;
1325
1326 dc.GetTextExtent(wxT("..."), &WSoFar, NULL);
1327 if ( WSoFar > r.width )
1328 {
1329 // not enough space to draw anything
1330 return;
1331 }
1332
1333 s.Alloc(len);
1334 for (size_t i = 0; i < len; i++)
1335 {
1336 dc.GetTextExtent(title[i], &letterW, NULL);
1337 if ( letterW + WSoFar > r.width )
1338 break;
1339 WSoFar += letterW;
1340 s << title[i];
1341 }
1342 s << wxT("...");
1343 }
1344 else // no need to truncate the title
1345 {
1346 s = title;
1347 }
1348
1349 dc.DrawLabel(s, wxNullBitmap, r, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
1350 }
1351
1352 void wxStdRenderer::DrawFrameIcon(wxDC& dc,
1353 const wxRect& rect,
1354 const wxIcon& icon,
1355 int flags)
1356 {
1357 if ( icon.Ok() )
1358 {
1359 wxRect r = GetFrameClientArea(rect, flags & ~wxTOPLEVEL_TITLEBAR);
1360 dc.DrawIcon(icon, r.x, r.y);
1361 }
1362 }
1363
1364 void wxStdRenderer::DrawFrameButton(wxDC& dc,
1365 wxCoord x, wxCoord y,
1366 int button,
1367 int flags)
1368 {
1369 FrameButtonType idx;
1370 switch (button)
1371 {
1372 case wxTOPLEVEL_BUTTON_CLOSE: idx = FrameButton_Close; break;
1373 case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
1374 case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
1375 case wxTOPLEVEL_BUTTON_RESTORE: idx = FrameButton_Restore; break;
1376 case wxTOPLEVEL_BUTTON_HELP: idx = FrameButton_Help; break;
1377 default:
1378 wxFAIL_MSG(wxT("incorrect button specification"));
1379 return;
1380 }
1381
1382 wxBitmap bmp = GetFrameButtonBitmap(idx);
1383 if ( !bmp.Ok() )
1384 return;
1385
1386 wxRect rectBtn(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
1387 if ( flags & wxCONTROL_PRESSED )
1388 {
1389 DrawSunkenBorder(dc, &rectBtn);
1390
1391 rectBtn.x++;
1392 rectBtn.y++;
1393 }
1394 else
1395 {
1396 DrawRaisedBorder(dc, &rectBtn);
1397 }
1398
1399 DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rectBtn);
1400
1401 wxRect rectBmp(0, 0, bmp.GetWidth(), bmp.GetHeight());
1402 dc.DrawBitmap(bmp, rectBmp.CentreIn(rectBtn).GetPosition(), true);
1403 }
1404
1405
1406 wxRect wxStdRenderer::GetFrameClientArea(const wxRect& rect, int flags) const
1407 {
1408 wxRect r(rect);
1409
1410 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
1411 {
1412 int border = flags & wxTOPLEVEL_RESIZEABLE
1413 ? RESIZEABLE_FRAME_BORDER_THICKNESS
1414 : FRAME_BORDER_THICKNESS;
1415 r.Inflate(-border);
1416 }
1417
1418 if ( flags & wxTOPLEVEL_TITLEBAR )
1419 {
1420 r.y += FRAME_TITLEBAR_HEIGHT;
1421 r.height -= FRAME_TITLEBAR_HEIGHT;
1422 }
1423
1424 return r;
1425 }
1426
1427 wxSize
1428 wxStdRenderer::GetFrameTotalSize(const wxSize& clientSize, int flags) const
1429 {
1430 wxSize s(clientSize);
1431
1432 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
1433 {
1434 int border = flags & wxTOPLEVEL_RESIZEABLE
1435 ? RESIZEABLE_FRAME_BORDER_THICKNESS
1436 : FRAME_BORDER_THICKNESS;
1437 s.x += 2*border;
1438 s.y += 2*border;
1439 }
1440
1441 if ( flags & wxTOPLEVEL_TITLEBAR )
1442 s.y += FRAME_TITLEBAR_HEIGHT;
1443
1444 return s;
1445 }
1446
1447 wxSize wxStdRenderer::GetFrameMinSize(int flags) const
1448 {
1449 wxSize s;
1450
1451 if ( (flags & wxTOPLEVEL_BORDER) && !(flags & wxTOPLEVEL_MAXIMIZED) )
1452 {
1453 int border = (flags & wxTOPLEVEL_RESIZEABLE) ?
1454 RESIZEABLE_FRAME_BORDER_THICKNESS :
1455 FRAME_BORDER_THICKNESS;
1456 s.x += 2*border;
1457 s.y += 2*border;
1458 }
1459
1460 if ( flags & wxTOPLEVEL_TITLEBAR )
1461 {
1462 s.y += FRAME_TITLEBAR_HEIGHT;
1463
1464 if ( flags & wxTOPLEVEL_ICON )
1465 s.x += FRAME_TITLEBAR_HEIGHT + 2;
1466 if ( flags & wxTOPLEVEL_BUTTON_CLOSE )
1467 s.x += FRAME_BUTTON_WIDTH + 2;
1468 if ( flags & wxTOPLEVEL_BUTTON_MAXIMIZE )
1469 s.x += FRAME_BUTTON_WIDTH;
1470 if ( flags & wxTOPLEVEL_BUTTON_RESTORE )
1471 s.x += FRAME_BUTTON_WIDTH;
1472 if ( flags & wxTOPLEVEL_BUTTON_ICONIZE )
1473 s.x += FRAME_BUTTON_WIDTH;
1474 if ( flags & wxTOPLEVEL_BUTTON_HELP )
1475 s.x += FRAME_BUTTON_WIDTH;
1476 }
1477
1478 return s;
1479 }
1480
1481 wxSize wxStdRenderer::GetFrameIconSize() const
1482 {
1483 return wxSize(16, 16);
1484 }
1485
wxWidgets (Impactor)