Commit | Line | Data |
---|---|---|
1e6feb95 VZ |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: univ/renderer.cpp | |
3 | // Purpose: wxControlRenderer implementation | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 15.08.00 | |
7 | // RCS-ID: $Id$ | |
442b35b5 | 8 | // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com) |
1e6feb95 VZ |
9 | // Licence: wxWindows license |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // =========================================================================== | |
13 | // declarations | |
14 | // =========================================================================== | |
15 | ||
16 | // --------------------------------------------------------------------------- | |
17 | // headers | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | #pragma implementation "renderer.h" | |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #ifndef WX_PRECOMP | |
32 | #include "wx/app.h" | |
33 | #include "wx/control.h" | |
34 | #include "wx/checklst.h" | |
35 | #include "wx/listbox.h" | |
36 | #include "wx/scrolbar.h" | |
37 | #include "wx/dc.h" | |
38 | #endif // WX_PRECOMP | |
39 | ||
40 | #include "wx/image.h" | |
41 | ||
42 | #include "wx/univ/theme.h" | |
43 | #include "wx/univ/renderer.h" | |
44 | #include "wx/univ/colschem.h" | |
45 | ||
8cb172b4 JS |
46 | #if wxUSE_GAUGE |
47 | #include "wx/gauge.h" | |
48 | #endif | |
49 | ||
1e6feb95 VZ |
50 | // ============================================================================ |
51 | // implementation | |
52 | // ============================================================================ | |
53 | ||
54 | // ---------------------------------------------------------------------------- | |
55 | // wxRenderer: drawing helpers | |
56 | // ---------------------------------------------------------------------------- | |
57 | ||
58 | void wxRenderer::StandardDrawFrame(wxDC& dc, | |
59 | const wxRect& rectFrame, | |
60 | const wxRect& rectLabel) | |
61 | { | |
62 | // draw left, bottom and right lines entirely | |
63 | DrawVerticalLine(dc, rectFrame.GetLeft(), | |
64 | rectFrame.GetTop(), rectFrame.GetBottom() - 2); | |
65 | DrawHorizontalLine(dc, rectFrame.GetBottom() - 1, | |
66 | rectFrame.GetLeft(), rectFrame.GetRight()); | |
67 | DrawVerticalLine(dc, rectFrame.GetRight() - 1, | |
68 | rectFrame.GetTop(), rectFrame.GetBottom() - 1); | |
69 | ||
70 | // and 2 parts of the top line | |
71 | DrawHorizontalLine(dc, rectFrame.GetTop(), | |
72 | rectFrame.GetLeft() + 1, rectLabel.GetLeft()); | |
73 | DrawHorizontalLine(dc, rectFrame.GetTop(), | |
74 | rectLabel.GetRight(), rectFrame.GetRight() - 2); | |
75 | } | |
76 | ||
77 | /* static */ | |
78 | void wxRenderer::StandardDrawTextLine(wxDC& dc, | |
79 | const wxString& text, | |
80 | const wxRect& rect, | |
81 | int selStart, int selEnd, | |
82 | int flags) | |
83 | { | |
84 | if ( (selStart == -1) || !(flags & wxCONTROL_FOCUSED) ) | |
85 | { | |
86 | // just draw it as is | |
87 | dc.DrawText(text, rect.x, rect.y); | |
88 | } | |
89 | else // we have selection | |
90 | { | |
91 | wxCoord width, | |
92 | x = rect.x; | |
93 | ||
94 | // draw the part before selection | |
95 | wxString s(text, (size_t)selStart); | |
96 | if ( !s.empty() ) | |
97 | { | |
98 | dc.DrawText(s, x, rect.y); | |
99 | ||
100 | dc.GetTextExtent(s, &width, NULL); | |
101 | x += width; | |
102 | } | |
103 | ||
104 | // draw the selection itself | |
105 | s = wxString(text.c_str() + selStart, text.c_str() + selEnd); | |
106 | if ( !s.empty() ) | |
107 | { | |
108 | wxColour colFg = dc.GetTextForeground(), | |
109 | colBg = dc.GetTextBackground(); | |
110 | dc.SetTextForeground(wxTHEME_COLOUR(HIGHLIGHT_TEXT)); | |
111 | dc.SetTextBackground(wxTHEME_COLOUR(HIGHLIGHT)); | |
112 | dc.SetBackgroundMode(wxSOLID); | |
113 | ||
114 | dc.DrawText(s, x, rect.y); | |
115 | dc.GetTextExtent(s, &width, NULL); | |
116 | x += width; | |
117 | ||
118 | dc.SetBackgroundMode(wxTRANSPARENT); | |
119 | dc.SetTextBackground(colBg); | |
120 | dc.SetTextForeground(colFg); | |
121 | } | |
122 | ||
123 | // draw the final part | |
124 | s = text.c_str() + selEnd; | |
125 | if ( !s.empty() ) | |
126 | { | |
127 | dc.DrawText(s, x, rect.y); | |
128 | } | |
129 | } | |
130 | } | |
131 | ||
132 | // ---------------------------------------------------------------------------- | |
133 | // wxRenderer: scrollbar geometry | |
134 | // ---------------------------------------------------------------------------- | |
135 | ||
136 | /* static */ | |
137 | void wxRenderer::StandardScrollBarThumbSize(wxCoord length, | |
138 | int thumbPos, | |
139 | int thumbSize, | |
140 | int range, | |
141 | wxCoord *thumbStart, | |
142 | wxCoord *thumbEnd) | |
143 | { | |
144 | // the thumb can't be made less than this number of pixels | |
145 | static const wxCoord thumbMinWidth = 8; // FIXME: should be configurable | |
146 | ||
147 | *thumbStart = (length*thumbPos) / range; | |
148 | *thumbEnd = (length*(thumbPos + thumbSize)) / range; | |
149 | ||
150 | if ( *thumbEnd - *thumbStart < thumbMinWidth ) | |
151 | { | |
152 | // adjust the end if possible | |
153 | if ( *thumbStart <= length - thumbMinWidth ) | |
154 | { | |
155 | // yes, just make it wider | |
156 | *thumbEnd = *thumbStart + thumbMinWidth; | |
157 | } | |
158 | else // it is at the bottom of the scrollbar | |
159 | { | |
160 | // so move it a bit up | |
161 | *thumbStart = length - thumbMinWidth; | |
162 | *thumbEnd = length; | |
163 | } | |
164 | } | |
165 | } | |
166 | ||
167 | /* static */ | |
168 | wxRect wxRenderer::StandardGetScrollbarRect(const wxScrollBar *scrollbar, | |
169 | wxScrollBar::Element elem, | |
170 | int thumbPos, | |
171 | const wxSize& sizeArrow) | |
172 | { | |
173 | if ( thumbPos == -1 ) | |
174 | { | |
175 | thumbPos = scrollbar->GetThumbPosition(); | |
176 | } | |
177 | ||
178 | wxSize sizeTotal = scrollbar->GetClientSize(); | |
179 | wxCoord *start, *width, length, arrow; | |
180 | wxRect rect; | |
181 | if ( scrollbar->IsVertical() ) | |
182 | { | |
183 | rect.x = 0; | |
184 | rect.width = sizeTotal.x; | |
185 | length = sizeTotal.y; | |
186 | start = &rect.y; | |
187 | width = &rect.height; | |
188 | arrow = sizeArrow.y; | |
189 | } | |
190 | else // horizontal | |
191 | { | |
192 | rect.y = 0; | |
193 | rect.height = sizeTotal.y; | |
194 | length = sizeTotal.x; | |
195 | start = &rect.x; | |
196 | width = &rect.width; | |
197 | arrow = sizeArrow.x; | |
198 | } | |
199 | ||
200 | switch ( elem ) | |
201 | { | |
202 | case wxScrollBar::Element_Arrow_Line_1: | |
203 | *start = 0; | |
204 | *width = arrow; | |
205 | break; | |
206 | ||
207 | case wxScrollBar::Element_Arrow_Line_2: | |
208 | *start = length - arrow; | |
209 | *width = arrow; | |
210 | break; | |
211 | ||
212 | case wxScrollBar::Element_Arrow_Page_1: | |
213 | case wxScrollBar::Element_Arrow_Page_2: | |
214 | // we don't have them at all | |
215 | break; | |
216 | ||
217 | case wxScrollBar::Element_Thumb: | |
218 | case wxScrollBar::Element_Bar_1: | |
219 | case wxScrollBar::Element_Bar_2: | |
220 | // we need to calculate the thumb position - do it | |
221 | { | |
222 | length -= 2*arrow; | |
223 | wxCoord thumbStart, thumbEnd; | |
224 | int range = scrollbar->GetRange(); | |
225 | if ( !range ) | |
226 | { | |
227 | thumbStart = | |
228 | thumbEnd = 0; | |
229 | } | |
230 | else | |
231 | { | |
232 | StandardScrollBarThumbSize(length, | |
233 | thumbPos, | |
234 | scrollbar->GetThumbSize(), | |
235 | range, | |
236 | &thumbStart, | |
237 | &thumbEnd); | |
238 | } | |
239 | ||
240 | if ( elem == wxScrollBar::Element_Thumb ) | |
241 | { | |
242 | *start = thumbStart; | |
243 | *width = thumbEnd - thumbStart; | |
244 | } | |
245 | else if ( elem == wxScrollBar::Element_Bar_1 ) | |
246 | { | |
247 | *start = 0; | |
248 | *width = thumbStart; | |
249 | } | |
250 | else // elem == wxScrollBar::Element_Bar_2 | |
251 | { | |
252 | *start = thumbEnd; | |
253 | *width = length - thumbEnd; | |
254 | } | |
255 | ||
256 | // everything is relative to the start of the shaft so far | |
257 | *start += arrow; | |
258 | } | |
259 | break; | |
260 | ||
261 | case wxScrollBar::Element_Max: | |
262 | default: | |
263 | wxFAIL_MSG( _T("unknown scrollbar element") ); | |
264 | } | |
265 | ||
266 | return rect; | |
267 | } | |
268 | ||
269 | /* static */ | |
270 | wxCoord wxRenderer::StandardScrollBarSize(const wxScrollBar *scrollbar, | |
271 | const wxSize& sizeArrowSB) | |
272 | { | |
273 | wxCoord sizeArrow, sizeTotal; | |
274 | if ( scrollbar->GetWindowStyle() & wxVERTICAL ) | |
275 | { | |
276 | sizeArrow = sizeArrowSB.y; | |
277 | sizeTotal = scrollbar->GetSize().y; | |
278 | } | |
279 | else // horizontal | |
280 | { | |
281 | sizeArrow = sizeArrowSB.x; | |
282 | sizeTotal = scrollbar->GetSize().x; | |
283 | } | |
284 | ||
285 | return sizeTotal - 2*sizeArrow; | |
286 | } | |
287 | ||
288 | /* static */ | |
289 | wxCoord wxRenderer::StandardScrollbarToPixel(const wxScrollBar *scrollbar, | |
290 | int thumbPos, | |
291 | const wxSize& sizeArrow) | |
292 | { | |
293 | int range = scrollbar->GetRange(); | |
294 | if ( !range ) | |
295 | { | |
296 | // the only valid position anyhow | |
297 | return 0; | |
298 | } | |
299 | ||
300 | if ( thumbPos == -1 ) | |
301 | { | |
302 | // by default use the current thumb position | |
303 | thumbPos = scrollbar->GetThumbPosition(); | |
304 | } | |
305 | ||
306 | return ( thumbPos*StandardScrollBarSize(scrollbar, sizeArrow) ) / range | |
307 | + (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x); | |
308 | } | |
309 | ||
310 | /* static */ | |
311 | int wxRenderer::StandardPixelToScrollbar(const wxScrollBar *scrollbar, | |
312 | wxCoord coord, | |
313 | const wxSize& sizeArrow) | |
314 | { | |
315 | return ( (coord - (scrollbar->IsVertical() ? sizeArrow.y : sizeArrow.x)) * | |
316 | scrollbar->GetRange() ) / | |
317 | StandardScrollBarSize(scrollbar, sizeArrow); | |
318 | } | |
319 | ||
320 | /* static */ | |
321 | wxHitTest wxRenderer::StandardHitTestScrollbar(const wxScrollBar *scrollbar, | |
322 | const wxPoint& pt, | |
323 | const wxSize& sizeArrowSB) | |
324 | { | |
325 | // we only need to work with either x or y coord depending on the | |
326 | // orientation, choose one (but still check the other one to verify if the | |
327 | // mouse is in the window at all) | |
328 | wxCoord coord, sizeArrow, sizeTotal; | |
329 | wxSize size = scrollbar->GetSize(); | |
330 | if ( scrollbar->GetWindowStyle() & wxVERTICAL ) | |
331 | { | |
332 | if ( pt.x < 0 || pt.x > size.x ) | |
333 | return wxHT_NOWHERE; | |
334 | ||
335 | coord = pt.y; | |
336 | sizeArrow = sizeArrowSB.y; | |
337 | sizeTotal = size.y; | |
338 | } | |
339 | else // horizontal | |
340 | { | |
341 | if ( pt.y < 0 || pt.y > size.y ) | |
342 | return wxHT_NOWHERE; | |
343 | ||
344 | coord = pt.x; | |
345 | sizeArrow = sizeArrowSB.x; | |
346 | sizeTotal = size.x; | |
347 | } | |
348 | ||
349 | // test for the arrows first as it's faster | |
350 | if ( coord < 0 || coord > sizeTotal ) | |
351 | { | |
352 | return wxHT_NOWHERE; | |
353 | } | |
354 | else if ( coord < sizeArrow ) | |
355 | { | |
356 | return wxHT_SCROLLBAR_ARROW_LINE_1; | |
357 | } | |
358 | else if ( coord > sizeTotal - sizeArrow ) | |
359 | { | |
360 | return wxHT_SCROLLBAR_ARROW_LINE_2; | |
361 | } | |
362 | else | |
363 | { | |
364 | // calculate the thumb position in pixels | |
365 | sizeTotal -= 2*sizeArrow; | |
366 | wxCoord thumbStart, thumbEnd; | |
367 | int range = scrollbar->GetRange(); | |
368 | if ( !range ) | |
369 | { | |
370 | // clicking the scrollbar without range has no effect | |
371 | return wxHT_NOWHERE; | |
372 | } | |
373 | else | |
374 | { | |
375 | StandardScrollBarThumbSize(sizeTotal, | |
376 | scrollbar->GetThumbPosition(), | |
377 | scrollbar->GetThumbSize(), | |
378 | range, | |
379 | &thumbStart, | |
380 | &thumbEnd); | |
381 | } | |
382 | ||
383 | // now compare with the thumb position | |
384 | coord -= sizeArrow; | |
385 | if ( coord < thumbStart ) | |
386 | return wxHT_SCROLLBAR_BAR_1; | |
387 | else if ( coord > thumbEnd ) | |
388 | return wxHT_SCROLLBAR_BAR_2; | |
389 | else | |
390 | return wxHT_SCROLLBAR_THUMB; | |
391 | } | |
392 | } | |
393 | ||
394 | wxRenderer::~wxRenderer() | |
395 | { | |
396 | } | |
397 | ||
398 | // ---------------------------------------------------------------------------- | |
399 | // wxControlRenderer | |
400 | // ---------------------------------------------------------------------------- | |
401 | ||
402 | wxControlRenderer::wxControlRenderer(wxWindow *window, | |
403 | wxDC& dc, | |
404 | wxRenderer *renderer) | |
405 | : m_dc(dc) | |
406 | { | |
407 | m_window = window; | |
408 | m_renderer = renderer; | |
409 | ||
410 | wxSize size = m_window->GetClientSize(); | |
411 | m_rect.x = | |
412 | m_rect.y = 0; | |
413 | m_rect.width = size.x; | |
414 | m_rect.height = size.y; | |
415 | } | |
416 | ||
417 | void wxControlRenderer::DrawLabel(const wxBitmap& bitmap, | |
418 | wxCoord marginX, wxCoord marginY) | |
419 | { | |
420 | m_dc.SetFont(m_window->GetFont()); | |
421 | m_dc.SetTextForeground(m_window->GetForegroundColour()); | |
422 | ||
423 | wxString label = m_window->GetLabel(); | |
424 | if ( !label.empty() || bitmap.Ok() ) | |
425 | { | |
426 | wxRect rectLabel = m_rect; | |
427 | if ( bitmap.Ok() ) | |
428 | { | |
429 | rectLabel.Inflate(-marginX, -marginY); | |
430 | } | |
431 | ||
432 | wxControl *ctrl = wxStaticCast(m_window, wxControl); | |
433 | ||
434 | m_renderer->DrawButtonLabel(m_dc, | |
435 | label, | |
436 | bitmap, | |
437 | rectLabel, | |
438 | m_window->GetStateFlags(), | |
439 | ctrl->GetAlignment(), | |
440 | ctrl->GetAccelIndex()); | |
441 | } | |
442 | } | |
443 | ||
444 | void wxControlRenderer::DrawFrame() | |
445 | { | |
446 | m_dc.SetFont(m_window->GetFont()); | |
447 | m_dc.SetTextForeground(m_window->GetForegroundColour()); | |
448 | m_dc.SetTextBackground(m_window->GetBackgroundColour()); | |
449 | ||
450 | wxControl *ctrl = wxStaticCast(m_window, wxControl); | |
451 | ||
452 | m_renderer->DrawFrame(m_dc, | |
453 | m_window->GetLabel(), | |
454 | m_rect, | |
455 | m_window->GetStateFlags(), | |
456 | ctrl->GetAlignment(), | |
457 | ctrl->GetAccelIndex()); | |
458 | } | |
459 | ||
460 | void wxControlRenderer::DrawButtonBorder() | |
461 | { | |
462 | int flags = m_window->GetStateFlags(); | |
463 | ||
464 | m_renderer->DrawButtonBorder(m_dc, m_rect, flags, &m_rect); | |
465 | ||
466 | m_renderer->DrawBackground(m_dc, wxTHEME_BG_COLOUR(m_window), m_rect, flags); | |
467 | } | |
468 | ||
469 | void wxControlRenderer::DrawBitmap(const wxBitmap& bitmap) | |
470 | { | |
471 | int style = m_window->GetWindowStyle(); | |
472 | DrawBitmap(m_dc, bitmap, m_rect, | |
473 | style & wxALIGN_MASK, | |
474 | style & wxBI_EXPAND ? wxEXPAND : wxSTRETCH_NOT); | |
475 | } | |
476 | ||
477 | /* static */ | |
478 | void wxControlRenderer::DrawBitmap(wxDC &dc, | |
479 | const wxBitmap& bitmap, | |
480 | const wxRect& rect, | |
481 | int alignment, | |
482 | wxStretch stretch) | |
483 | { | |
484 | // we may change the bitmap if we stretch it | |
485 | wxBitmap bmp = bitmap; | |
486 | if ( !bmp.Ok() ) | |
487 | return; | |
488 | ||
489 | int width = bmp.GetWidth(), | |
490 | height = bmp.GetHeight(); | |
491 | ||
492 | wxCoord x = 0, | |
493 | y = 0; | |
494 | if ( stretch & wxTILE ) | |
495 | { | |
496 | // tile the bitmap | |
497 | for ( ; x < rect.width; x += width ) | |
498 | { | |
499 | for ( y = 0; y < rect.height; y += height ) | |
500 | { | |
501 | // no need to use mask here as we cover the entire window area | |
502 | dc.DrawBitmap(bmp, x, y); | |
503 | } | |
504 | } | |
505 | } | |
506 | else if ( stretch & wxEXPAND ) | |
507 | { | |
508 | // stretch bitmap to fill the entire control | |
509 | bmp = wxImage(bmp).Scale(rect.width, rect.height).ConvertToBitmap(); | |
510 | } | |
511 | else // not stretched, not tiled | |
512 | { | |
513 | if ( alignment & wxALIGN_RIGHT ) | |
514 | { | |
515 | x = rect.GetRight() - width; | |
516 | } | |
517 | else if ( alignment & wxALIGN_CENTRE ) | |
518 | { | |
519 | x = (rect.GetLeft() + rect.GetRight() - width + 1) / 2; | |
520 | } | |
521 | else // alignment & wxALIGN_LEFT | |
522 | { | |
523 | x = rect.GetLeft(); | |
524 | } | |
525 | ||
526 | if ( alignment & wxALIGN_BOTTOM ) | |
527 | { | |
528 | y = rect.GetBottom() - height; | |
529 | } | |
530 | else if ( alignment & wxALIGN_CENTRE_VERTICAL ) | |
531 | { | |
532 | y = (rect.GetTop() + rect.GetBottom() - height + 1) / 2; | |
533 | } | |
534 | else // alignment & wxALIGN_TOP | |
535 | { | |
536 | y = rect.GetTop(); | |
537 | } | |
538 | } | |
539 | ||
540 | // do draw it | |
541 | dc.DrawBitmap(bmp, x, y, TRUE /* use mask */); | |
542 | } | |
543 | ||
544 | void wxControlRenderer::DrawScrollbar(const wxScrollBar *scrollbar, | |
545 | int thumbPosOld) | |
546 | { | |
547 | // we will only redraw the parts which must be redrawn and not everything | |
548 | wxRegion rgnUpdate = scrollbar->GetUpdateRegion(); | |
549 | ||
550 | { | |
551 | wxRect rectUpdate = rgnUpdate.GetBox(); | |
552 | wxLogTrace(_T("scrollbar"), | |
553 | _T("%s redraw: update box is (%d, %d)-(%d, %d)"), | |
554 | scrollbar->IsVertical() ? _T("vert") : _T("horz"), | |
555 | rectUpdate.GetLeft(), | |
556 | rectUpdate.GetTop(), | |
557 | rectUpdate.GetRight(), | |
558 | rectUpdate.GetBottom()); | |
559 | ||
560 | #if 0 //def WXDEBUG_SCROLLBAR | |
561 | static bool s_refreshDebug = FALSE; | |
562 | if ( s_refreshDebug ) | |
563 | { | |
564 | wxClientDC dc(wxConstCast(scrollbar, wxScrollBar)); | |
565 | dc.SetBrush(*wxRED_BRUSH); | |
566 | dc.SetPen(*wxTRANSPARENT_PEN); | |
567 | dc.DrawRectangle(rectUpdate); | |
568 | ||
569 | // under Unix we use "--sync" X option for this | |
570 | #ifdef __WXMSW__ | |
571 | ::GdiFlush(); | |
572 | ::Sleep(200); | |
573 | #endif // __WXMSW__ | |
574 | } | |
575 | #endif // WXDEBUG_SCROLLBAR | |
576 | } | |
577 | ||
578 | wxOrientation orient = scrollbar->IsVertical() ? wxVERTICAL | |
579 | : wxHORIZONTAL; | |
580 | ||
581 | // the shaft | |
582 | for ( int nBar = 0; nBar < 2; nBar++ ) | |
583 | { | |
584 | wxScrollBar::Element elem = | |
585 | (wxScrollBar::Element)(wxScrollBar::Element_Bar_1 + nBar); | |
586 | ||
587 | wxRect rectBar = m_renderer->GetScrollbarRect(scrollbar, elem); | |
588 | ||
589 | if ( rgnUpdate.Contains(rectBar) ) | |
590 | { | |
591 | wxLogTrace(_T("scrollbar"), | |
592 | _T("drawing bar part %d at (%d, %d)-(%d, %d)"), | |
593 | nBar + 1, | |
594 | rectBar.GetLeft(), | |
595 | rectBar.GetTop(), | |
596 | rectBar.GetRight(), | |
597 | rectBar.GetBottom()); | |
598 | ||
599 | m_renderer->DrawScrollbarShaft(m_dc, | |
600 | orient, | |
601 | rectBar, | |
602 | scrollbar->GetState(elem)); | |
603 | } | |
604 | } | |
605 | ||
606 | // arrows | |
607 | for ( int nArrow = 0; nArrow < 2; nArrow++ ) | |
608 | { | |
609 | wxScrollBar::Element elem = | |
610 | (wxScrollBar::Element)(wxScrollBar::Element_Arrow_Line_1 + nArrow); | |
611 | ||
612 | wxRect rectArrow = m_renderer->GetScrollbarRect(scrollbar, elem); | |
613 | if ( rgnUpdate.Contains(rectArrow) ) | |
614 | { | |
615 | wxLogTrace(_T("scrollbar"), | |
616 | _T("drawing arrow %d at (%d, %d)-(%d, %d)"), | |
617 | nArrow + 1, | |
618 | rectArrow.GetLeft(), | |
619 | rectArrow.GetTop(), | |
620 | rectArrow.GetRight(), | |
621 | rectArrow.GetBottom()); | |
622 | ||
623 | scrollbar->GetArrows().DrawArrow | |
624 | ( | |
625 | (wxScrollArrows::Arrow)nArrow, | |
626 | m_dc, | |
627 | rectArrow, | |
628 | TRUE // draw a scrollbar arrow, not just an arrow | |
629 | ); | |
630 | } | |
631 | } | |
632 | ||
633 | // TODO: support for page arrows | |
634 | ||
635 | // and the thumb | |
636 | wxScrollBar::Element elem = wxScrollBar::Element_Thumb; | |
637 | wxRect rectThumb = m_renderer->GetScrollbarRect(scrollbar, elem); | |
638 | if ( rectThumb.width && rectThumb.height && rgnUpdate.Contains(rectThumb) ) | |
639 | { | |
640 | wxLogTrace(_T("scrollbar"), | |
641 | _T("drawing thumb at (%d, %d)-(%d, %d)"), | |
642 | rectThumb.GetLeft(), | |
643 | rectThumb.GetTop(), | |
644 | rectThumb.GetRight(), | |
645 | rectThumb.GetBottom()); | |
646 | ||
647 | m_renderer->DrawScrollbarThumb(m_dc, | |
648 | orient, | |
649 | rectThumb, | |
650 | scrollbar->GetState(elem)); | |
651 | } | |
652 | } | |
653 | ||
654 | void wxControlRenderer::DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) | |
655 | { | |
656 | wxASSERT_MSG( x1 == x2 || y1 == y2, | |
657 | _T("line must be either horizontal or vertical") ); | |
658 | ||
659 | if ( x1 == x2 ) | |
660 | m_renderer->DrawVerticalLine(m_dc, x1, y1, y2); | |
661 | else // horizontal | |
662 | m_renderer->DrawHorizontalLine(m_dc, y1, x1, x2); | |
663 | } | |
664 | ||
665 | #if wxUSE_LISTBOX | |
666 | ||
667 | void wxControlRenderer::DrawItems(const wxListBox *lbox, | |
668 | size_t itemFirst, size_t itemLast) | |
669 | { | |
670 | DoDrawItems(lbox, itemFirst, itemLast); | |
671 | } | |
672 | ||
673 | void wxControlRenderer::DoDrawItems(const wxListBox *lbox, | |
674 | size_t itemFirst, size_t itemLast, | |
675 | bool isCheckLbox) | |
676 | { | |
677 | // prepare for the drawing: calc the initial position | |
678 | wxCoord lineHeight = lbox->GetLineHeight(); | |
679 | ||
680 | // note that SetClippingRegion() needs the physical (unscrolled) | |
681 | // coordinates while we use the logical (scrolled) ones for the drawing | |
682 | // itself | |
683 | wxRect rect; | |
684 | wxSize size = lbox->GetClientSize(); | |
685 | rect.width = size.x; | |
686 | rect.height = size.y; | |
687 | ||
688 | // keep the text inside the client rect or we will overwrite the vertical | |
689 | // scrollbar for the long strings | |
690 | m_dc.SetClippingRegion(rect.x, rect.y, rect.width + 1, rect.height + 1); | |
691 | ||
692 | // adjust the rect position now | |
693 | lbox->CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y); | |
694 | rect.y += itemFirst*lineHeight; | |
695 | rect.height = lineHeight; | |
696 | ||
697 | // the rect should go to the right visible border so adjust the width if x | |
698 | // is shifted (rightmost point should stay the same) | |
699 | rect.width -= rect.x; | |
700 | ||
701 | // we'll keep the text colour unchanged | |
702 | m_dc.SetTextForeground(lbox->GetForegroundColour()); | |
703 | ||
704 | // an item should have the focused rect only when the lbox has focus, so | |
705 | // make sure that we never set wxCONTROL_FOCUSED flag if it doesn't | |
706 | int itemCurrent = wxWindow::FindFocus() == (wxWindow *)lbox // cast needed | |
707 | ? lbox->GetCurrentItem() | |
708 | : -1; | |
709 | for ( size_t n = itemFirst; n < itemLast; n++ ) | |
710 | { | |
711 | int flags = 0; | |
712 | if ( (int)n == itemCurrent ) | |
713 | flags |= wxCONTROL_FOCUSED; | |
714 | if ( lbox->IsSelected(n) ) | |
715 | flags |= wxCONTROL_SELECTED; | |
716 | ||
717 | #if wxUSE_CHECKLISTBOX | |
718 | if ( isCheckLbox ) | |
719 | { | |
720 | wxCheckListBox *checklstbox = wxStaticCast(lbox, wxCheckListBox); | |
721 | if ( checklstbox->IsChecked(n) ) | |
722 | flags |= wxCONTROL_CHECKED; | |
723 | ||
724 | m_renderer->DrawCheckItem(m_dc, lbox->GetString(n), | |
725 | wxNullBitmap, | |
726 | rect, | |
727 | flags); | |
728 | } | |
729 | else | |
730 | #endif // wxUSE_CHECKLISTBOX | |
731 | { | |
732 | m_renderer->DrawItem(m_dc, lbox->GetString(n), rect, flags); | |
733 | } | |
734 | ||
735 | rect.y += lineHeight; | |
736 | } | |
737 | } | |
738 | ||
739 | #endif // wxUSE_LISTBOX | |
740 | ||
741 | #if wxUSE_CHECKLISTBOX | |
742 | ||
743 | void wxControlRenderer::DrawCheckItems(const wxCheckListBox *lbox, | |
744 | size_t itemFirst, size_t itemLast) | |
745 | { | |
746 | DoDrawItems(lbox, itemFirst, itemLast, TRUE); | |
747 | } | |
748 | ||
749 | #endif // wxUSE_CHECKLISTBOX | |
750 | ||
751 | #if wxUSE_GAUGE | |
752 | ||
753 | void wxControlRenderer::DrawProgressBar(const wxGauge *gauge) | |
754 | { | |
755 | // draw background | |
756 | m_dc.SetBrush(wxBrush(m_window->GetBackgroundColour(), wxSOLID)); | |
757 | m_dc.SetPen(*wxTRANSPARENT_PEN); | |
758 | m_dc.DrawRectangle(m_rect); | |
759 | ||
760 | int max = gauge->GetRange(); | |
761 | if ( !max ) | |
762 | { | |
763 | // nothing to draw | |
764 | return; | |
765 | } | |
766 | ||
767 | // calc the filled rect | |
768 | int pos = gauge->GetValue(); | |
769 | int left = max - pos; | |
770 | ||
771 | wxRect rect = m_rect; | |
772 | rect.Deflate(1); // FIXME this depends on the border width | |
773 | ||
774 | m_dc.SetBrush(wxBrush(m_window->GetForegroundColour(), wxSOLID)); | |
775 | ||
776 | if ( gauge->IsSmooth() ) | |
777 | { | |
778 | // just draw the rectangle in one go | |
779 | if ( gauge->IsVertical() ) | |
780 | { | |
781 | // vert bars grow from bottom to top | |
782 | wxCoord dy = ((rect.height - 1) * left) / max; | |
783 | rect.y += dy; | |
784 | rect.height -= dy; | |
785 | } | |
786 | else // horizontal | |
787 | { | |
788 | // grow from left to right | |
789 | rect.width -= ((rect.width - 1) * left) / max; | |
790 | } | |
791 | ||
792 | m_dc.DrawRectangle(rect); | |
793 | } | |
794 | else // discrete | |
795 | { | |
796 | wxSize sizeStep = m_renderer->GetProgressBarStep(); | |
797 | int step = gauge->IsVertical() ? sizeStep.y : sizeStep.x; | |
798 | ||
799 | // we divide by it below! | |
800 | wxCHECK_RET( step, _T("invalid wxGauge step") ); | |
801 | ||
802 | // round up to make the progress appear to start faster | |
803 | int lenTotal = gauge->IsVertical() ? rect.height : rect.width; | |
804 | int steps = ((lenTotal + step - 1) * pos) / (max * step); | |
805 | ||
806 | // calc the coords of one small rect | |
807 | wxCoord *px, dx, dy; | |
808 | if ( gauge->IsVertical() ) | |
809 | { | |
810 | // draw from bottom to top: so first set y to the bottom | |
811 | rect.y += rect.height - 1; | |
812 | ||
813 | // then adjust the height | |
814 | rect.height = step; | |
815 | ||
816 | // and then adjust y again to be what it should for the first rect | |
817 | rect.y -= rect.height; | |
818 | ||
819 | // we are going up | |
820 | step = -step; | |
821 | ||
822 | // remember that this will be the coord which will change | |
823 | px = &rect.y; | |
824 | ||
825 | dy = 1; | |
826 | dx = 0; | |
827 | } | |
828 | else // horizontal | |
829 | { | |
830 | // don't leave 2 empty pixels in the beginning | |
831 | rect.x--; | |
832 | ||
833 | px = &rect.x; | |
834 | rect.width = step; | |
835 | ||
836 | dy = 0; | |
837 | dx = 1; | |
838 | } | |
839 | ||
840 | for ( int n = 0; n < steps; n++ ) | |
841 | { | |
842 | wxRect rectSegment = rect; | |
843 | rectSegment.Deflate(dx, dy); | |
844 | ||
845 | m_dc.DrawRectangle(rectSegment); | |
846 | ||
847 | *px += step; | |
848 | if ( *px < 1 ) | |
849 | { | |
850 | // this can only happen for the last step of vertical gauge | |
851 | rect.height = *px - step - 1; | |
852 | *px = 1; | |
853 | } | |
854 | else if ( *px > lenTotal - step ) | |
855 | { | |
856 | // this can only happen for the last step of horizontal gauge | |
857 | rect.width = lenTotal - *px - 1; | |
858 | } | |
859 | } | |
860 | } | |
861 | } | |
862 | ||
863 | #endif // wxUSE_GAUGE | |
864 |