/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/generic/renderg.cpp
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/src/generic/renderg.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 11 months ago) by william
File size: 22037 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/renderg.cpp
3 // Purpose: generic implementation of wxRendererNative (for any platform)
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 20.07.2003
7 // RCS-ID: $Id: renderg.cpp 45498 2007-04-16 13:03:05Z VZ $
8 // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
9 // License: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/renderer.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/string.h"
31 #include "wx/dc.h"
32 #include "wx/settings.h"
33 #include "wx/gdicmn.h"
34 #include "wx/module.h"
35 #endif //WX_PRECOMP
36
37 #include "wx/splitter.h"
38 #include "wx/dcmirror.h"
39
40 // ----------------------------------------------------------------------------
41 // wxRendererGeneric: our wxRendererNative implementation
42 // ----------------------------------------------------------------------------
43
44 class WXDLLEXPORT wxRendererGeneric : public wxRendererNative
45 {
46 public:
47 wxRendererGeneric();
48
49 virtual int DrawHeaderButton(wxWindow *win,
50 wxDC& dc,
51 const wxRect& rect,
52 int flags = 0,
53 wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
54 wxHeaderButtonParams* params = NULL);
55
56 virtual int DrawHeaderButtonContents(wxWindow *win,
57 wxDC& dc,
58 const wxRect& rect,
59 int flags = 0,
60 wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE,
61 wxHeaderButtonParams* params = NULL);
62
63 virtual int GetHeaderButtonHeight(wxWindow *win);
64
65 virtual void DrawTreeItemButton(wxWindow *win,
66 wxDC& dc,
67 const wxRect& rect,
68 int flags = 0);
69
70 virtual void DrawSplitterBorder(wxWindow *win,
71 wxDC& dc,
72 const wxRect& rect,
73 int flags = 0);
74
75 virtual void DrawSplitterSash(wxWindow *win,
76 wxDC& dc,
77 const wxSize& size,
78 wxCoord position,
79 wxOrientation orient,
80 int flags = 0);
81
82 virtual void DrawComboBoxDropButton(wxWindow *win,
83 wxDC& dc,
84 const wxRect& rect,
85 int flags = 0);
86
87 virtual void DrawDropArrow(wxWindow *win,
88 wxDC& dc,
89 const wxRect& rect,
90 int flags = 0);
91
92 virtual void DrawCheckBox(wxWindow *win,
93 wxDC& dc,
94 const wxRect& rect,
95 int flags = 0);
96
97 virtual void DrawPushButton(wxWindow *win,
98 wxDC& dc,
99 const wxRect& rect,
100 int flags = 0);
101
102 virtual void DrawItemSelectionRect(wxWindow *win,
103 wxDC& dc,
104 const wxRect& rect,
105 int flags = 0);
106
107 virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win);
108
109 virtual wxRendererVersion GetVersion() const
110 {
111 return wxRendererVersion(wxRendererVersion::Current_Version,
112 wxRendererVersion::Current_Age);
113 }
114
115
116 // Cleanup by deleting standard renderer
117 static void Cleanup();
118
119 // Get the generic object
120 static wxRendererGeneric* DoGetGeneric();
121
122 protected:
123 // draw the rectange using the first pen for the left and top sides and
124 // the second one for the bottom and right ones
125 void DrawShadedRect(wxDC& dc, wxRect *rect,
126 const wxPen& pen1, const wxPen& pen2);
127
128 // the standard pens
129 wxPen m_penBlack,
130 m_penDarkGrey,
131 m_penLightGrey,
132 m_penHighlight;
133
134 static wxRendererGeneric* sm_rendererGeneric;
135 };
136
137 // ============================================================================
138 // wxRendererGeneric implementation
139 // ============================================================================
140
141 // Get the generic object
142 wxRendererGeneric* wxRendererGeneric::DoGetGeneric()
143 {
144 if (!sm_rendererGeneric)
145 sm_rendererGeneric = new wxRendererGeneric;
146 return sm_rendererGeneric;
147 }
148
149 // ----------------------------------------------------------------------------
150 // wxRendererGeneric creation
151 // ----------------------------------------------------------------------------
152
153 /* static */
154 wxRendererNative& wxRendererNative::GetGeneric()
155 {
156 return * wxRendererGeneric::DoGetGeneric();
157 }
158
159 void wxRendererGeneric::Cleanup()
160 {
161 if (sm_rendererGeneric)
162 delete sm_rendererGeneric;
163
164 sm_rendererGeneric = NULL;
165 }
166
167 wxRendererGeneric* wxRendererGeneric::sm_rendererGeneric = NULL;
168
169 wxRendererGeneric::wxRendererGeneric()
170 : m_penBlack(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW)),
171 m_penDarkGrey(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)),
172 m_penLightGrey(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)),
173 m_penHighlight(wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT))
174 {
175 }
176
177 // ----------------------------------------------------------------------------
178 // wxRendererGeneric helpers
179 // ----------------------------------------------------------------------------
180
181 void
182 wxRendererGeneric::DrawShadedRect(wxDC& dc,
183 wxRect *rect,
184 const wxPen& pen1,
185 const wxPen& pen2)
186 {
187 // draw the rectangle
188 dc.SetPen(pen1);
189 dc.DrawLine(rect->GetLeft(), rect->GetTop(),
190 rect->GetLeft(), rect->GetBottom());
191 dc.DrawLine(rect->GetLeft() + 1, rect->GetTop(),
192 rect->GetRight(), rect->GetTop());
193 dc.SetPen(pen2);
194 dc.DrawLine(rect->GetRight(), rect->GetTop(),
195 rect->GetRight(), rect->GetBottom());
196 dc.DrawLine(rect->GetLeft(), rect->GetBottom(),
197 rect->GetRight() + 1, rect->GetBottom());
198
199 // adjust the rect
200 rect->Inflate(-1);
201 }
202
203 // ----------------------------------------------------------------------------
204 // tree/list ctrl drawing
205 // ----------------------------------------------------------------------------
206
207 int
208 wxRendererGeneric::DrawHeaderButton(wxWindow* win,
209 wxDC& dc,
210 const wxRect& rect,
211 int flags,
212 wxHeaderSortIconType sortArrow,
213 wxHeaderButtonParams* params)
214 {
215 const int CORNER = 1;
216
217 const wxCoord x = rect.x,
218 y = rect.y,
219 w = rect.width,
220 h = rect.height;
221
222 dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)));
223 dc.SetPen(*wxTRANSPARENT_PEN);
224 dc.DrawRectangle(rect);
225
226 dc.SetBrush(*wxTRANSPARENT_BRUSH);
227
228 dc.SetPen(m_penBlack);
229 dc.DrawLine( x+w-CORNER+1, y, x+w, y+h ); // right (outer)
230 dc.DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
231
232 dc.SetPen(m_penDarkGrey);
233 dc.DrawLine( x+w-CORNER, y, x+w-1, y+h ); // right (inner)
234 dc.DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
235
236 dc.SetPen(m_penHighlight);
237 dc.DrawRectangle( x, y, w-CORNER+1, 1 ); // top (outer)
238 dc.DrawRectangle( x, y, 1, h ); // left (outer)
239 dc.DrawLine( x, y+h-1, x+1, y+h-1 );
240 dc.DrawLine( x+w-1, y, x+w-1, y+1 );
241
242 return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params);
243 }
244
245
246 int
247 wxRendererGeneric::DrawHeaderButtonContents(wxWindow *win,
248 wxDC& dc,
249 const wxRect& rect,
250 int flags,
251 wxHeaderSortIconType sortArrow,
252 wxHeaderButtonParams* params)
253 {
254 int labelWidth = 0;
255
256 // Mark this item as selected. For the generic version we'll just draw an
257 // underline
258 if ( flags & wxCONTROL_SELECTED )
259 {
260 // draw a line at the bottom of the header button, overlaying the
261 // native hot-tracking line (on XP)
262 const int penwidth = 3;
263 int y = rect.y + rect.height + 1 - penwidth;
264 wxColour c = (params && params->m_selectionColour.Ok()) ?
265 params->m_selectionColour : wxColour(0x66, 0x66, 0x66);
266 wxPen pen(c, penwidth);
267 pen.SetCap(wxCAP_BUTT);
268 dc.SetPen(pen);
269 dc.DrawLine(rect.x, y, rect.x + rect.width, y);
270 }
271
272 // Draw an up or down arrow
273 int arrowSpace = 0;
274 if (sortArrow != wxHDR_SORT_ICON_NONE )
275 {
276 wxRect ar = rect;
277
278 // make a rect for the arrow
279 ar.height = 4;
280 ar.width = 8;
281 ar.y += (rect.height - ar.height)/2;
282 ar.x = ar.x + rect.width - 3*ar.width/2;
283 arrowSpace = 3*ar.width/2; // space to preserve when drawing the label
284
285 wxPoint triPt[3];
286 if ( sortArrow & wxHDR_SORT_ICON_UP )
287 {
288 triPt[0].x = ar.width / 2;
289 triPt[0].y = 0;
290 triPt[1].x = ar.width;
291 triPt[1].y = ar.height;
292 triPt[2].x = 0;
293 triPt[2].y = ar.height;
294 }
295 else
296 {
297 triPt[0].x = 0;
298 triPt[0].y = 0;
299 triPt[1].x = ar.width;
300 triPt[1].y = 0;
301 triPt[2].x = ar.width / 2;
302 triPt[2].y = ar.height;
303 }
304
305 wxColour c = (params && params->m_arrowColour.Ok()) ?
306 params->m_arrowColour : wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW);
307 dc.SetPen(wxPen(c));
308 dc.SetBrush(wxBrush(c));
309 dc.DrawPolygon( 3, triPt, ar.x, ar.y);
310 }
311 labelWidth += arrowSpace;
312
313 const int margin = 5; // number of pixels to reserve on either side of the label
314 int bmpWidth = 0;
315 int txtEnd = 0;
316
317 if ( params && params->m_labelBitmap.Ok() )
318 bmpWidth = params->m_labelBitmap.GetWidth() + 2;
319
320 labelWidth += bmpWidth + 2*margin;
321
322 // Draw a label if one is given
323 if ( params && !params->m_labelText.empty() )
324 {
325 wxFont font = params->m_labelFont.Ok() ?
326 params->m_labelFont : win->GetFont();
327 wxColour clr = params->m_labelColour.Ok() ?
328 params->m_labelColour : win->GetForegroundColour();
329
330 wxString label( params->m_labelText );
331
332 dc.SetFont(font);
333 dc.SetTextForeground(clr);
334 dc.SetBackgroundMode(wxTRANSPARENT);
335
336 int tw, th, td, x, y;
337 dc.GetTextExtent( label, &tw, &th, &td);
338 labelWidth += tw;
339 y = rect.y + wxMax(0, (rect.height - (th+td)) / 2);
340
341 // truncate and add an ellipsis (...) if the text is too wide.
342 int targetWidth = rect.width - arrowSpace - bmpWidth - 2*margin;
343 if ( tw > targetWidth )
344 {
345 int ellipsisWidth;
346 dc.GetTextExtent( wxT("..."), &ellipsisWidth, NULL);
347 do {
348 label.Truncate( label.length() - 1 );
349 dc.GetTextExtent( label, &tw, &th);
350 } while (tw + ellipsisWidth > targetWidth && label.length() );
351 label.append( wxT("...") );
352 tw += ellipsisWidth;
353 }
354
355 switch (params->m_labelAlignment)
356 {
357 default:
358 case wxALIGN_LEFT:
359 x = rect.x + margin;
360 break;
361 case wxALIGN_CENTER:
362 x = rect.x + wxMax(0, (rect.width - arrowSpace - tw - bmpWidth)/2);
363 break;
364 case wxALIGN_RIGHT:
365 x = rect.x + wxMax(0, rect.width - arrowSpace - margin - tw - bmpWidth);
366 break;
367 }
368
369 dc.DrawText(label, x, y);
370 txtEnd = x + tw + 2;
371 }
372
373 // draw the bitmap if there is one
374 if ( params && params->m_labelBitmap.Ok() )
375 {
376 int w, h, x, y;
377 w = params->m_labelBitmap.GetWidth();
378 h = params->m_labelBitmap.GetHeight();
379
380 y = rect.y + wxMax(1, (rect.height - h) / 2);
381
382 // if there is a text label, then put the bitmap at the end of the label
383 if ( txtEnd != 0 )
384 {
385 x = txtEnd;
386 }
387 // otherwise use the alignment flags
388 else
389 {
390 switch (params->m_labelAlignment)
391 {
392 default:
393 case wxALIGN_LEFT:
394 x = rect.x + margin;
395 break;
396 case wxALIGN_CENTER:
397 x = rect.x + wxMax(1, (rect.width - arrowSpace - w)/2);
398 break;
399 case wxALIGN_RIGHT:
400 x = rect.x + wxMax(1, rect.width - arrowSpace - margin - w);
401 break;
402 }
403 }
404 dc.DrawBitmap(params->m_labelBitmap, x, y, true);
405 }
406 return labelWidth;
407 }
408
409
410 int wxRendererGeneric::GetHeaderButtonHeight(wxWindow *win)
411 {
412 // Copied and adapted from src/generic/listctrl.cpp
413 const int HEADER_OFFSET_Y = 1;
414 const int EXTRA_HEIGHT = 4;
415
416 int w=0, h=14, d=0;
417 if (win)
418 win->GetTextExtent(wxT("Hg"), &w, &h, &d);
419
420 return h + d + 2 * HEADER_OFFSET_Y + EXTRA_HEIGHT;
421 }
422
423
424 // draw the plus or minus sign
425 void
426 wxRendererGeneric::DrawTreeItemButton(wxWindow * WXUNUSED(win),
427 wxDC& dc,
428 const wxRect& rect,
429 int flags)
430 {
431 // store settings
432 wxDCPenChanger penChanger(dc, *wxGREY_PEN);
433 wxDCBrushChanger brushChanger(dc, *wxWHITE_BRUSH);
434
435 dc.DrawRectangle(rect);
436
437 // black lines
438 const wxCoord xMiddle = rect.x + rect.width/2;
439 const wxCoord yMiddle = rect.y + rect.height/2;
440
441 // half of the length of the horz lines in "-" and "+"
442 const wxCoord halfWidth = rect.width/2 - 2;
443 dc.SetPen(*wxBLACK_PEN);
444 dc.DrawLine(xMiddle - halfWidth, yMiddle,
445 xMiddle + halfWidth + 1, yMiddle);
446
447 if ( !(flags & wxCONTROL_EXPANDED) )
448 {
449 // turn "-" into "+"
450 const wxCoord halfHeight = rect.height/2 - 2;
451 dc.DrawLine(xMiddle, yMiddle - halfHeight,
452 xMiddle, yMiddle + halfHeight + 1);
453 }
454 }
455
456 // ----------------------------------------------------------------------------
457 // sash drawing
458 // ----------------------------------------------------------------------------
459
460 wxSplitterRenderParams
461 wxRendererGeneric::GetSplitterParams(const wxWindow *win)
462 {
463 // see below
464 wxCoord sashWidth,
465 border;
466
467 if ( win->HasFlag(wxSP_3DSASH) )
468 sashWidth = 7;
469 else if ( win->HasFlag(wxSP_NOSASH) )
470 sashWidth = 0;
471 else // no 3D effect
472 sashWidth = 3;
473
474 if ( win->HasFlag(wxSP_3DBORDER) )
475 border = 2;
476 else // no 3D effect
477 border = 0;
478
479 return wxSplitterRenderParams(sashWidth, border, false);
480 }
481
482 void
483 wxRendererGeneric::DrawSplitterBorder(wxWindow *win,
484 wxDC& dc,
485 const wxRect& rectOrig,
486 int WXUNUSED(falgs))
487 {
488 if ( win->HasFlag(wxSP_3DBORDER) )
489 {
490 wxRect rect = rectOrig;
491 DrawShadedRect(dc, &rect, m_penDarkGrey, m_penHighlight);
492 DrawShadedRect(dc, &rect, m_penBlack, m_penLightGrey);
493 }
494 }
495
496 void
497 wxRendererGeneric::DrawSplitterSash(wxWindow *win,
498 wxDC& dcReal,
499 const wxSize& sizeReal,
500 wxCoord position,
501 wxOrientation orient,
502 int WXUNUSED(flags))
503 {
504 // to avoid duplicating the same code for horizontal and vertical sashes,
505 // simply mirror the DC instead if needed (i.e. if horz splitter)
506 wxMirrorDC dc(dcReal, orient != wxVERTICAL);
507 wxSize size = dc.Reflect(sizeReal);
508
509
510 // we draw a Win32-like grey sash with possible 3D border here:
511 //
512 // ---- this is position
513 // /
514 // v
515 // dWGGGDd
516 // GWGGGDB
517 // GWGGGDB where G is light grey (face)
518 // GWGGGDB W white (light)
519 // GWGGGDB D dark grey (shadow)
520 // GWGGGDB B black (dark shadow)
521 // GWGGGDB
522 // GWGGGDB and lower letters are our border (already drawn)
523 // GWGGGDB
524 // wWGGGDd
525 //
526 // only the middle 3 columns are drawn unless wxSP_3D is specified
527
528 const wxCoord h = size.y;
529 wxCoord offset = 0;
530
531 // If we're drawing the border, draw the sash 3d lines shorter
532 if ( win->HasFlag(wxSP_3DBORDER) )
533 {
534 offset = 1;
535 }
536
537 dc.SetPen(*wxTRANSPARENT_PEN);
538 dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)));
539
540 if ( win->HasFlag(wxSP_3DSASH) )
541 {
542 // Draw the 3D sash
543 dc.DrawRectangle(position + 2, 0, 3, h);
544
545 dc.SetPen(m_penLightGrey);
546 dc.DrawLine(position, offset, position, h - offset);
547
548 dc.SetPen(m_penHighlight);
549 dc.DrawLine(position + 1, 0, position + 1, h);
550
551 dc.SetPen(m_penDarkGrey);
552 dc.DrawLine(position + 5, 0, position + 5, h);
553
554 dc.SetPen(m_penBlack);
555 dc.DrawLine(position + 6, offset, position + 6, h - offset);
556 }
557 else
558 {
559 // Draw a flat sash
560 dc.DrawRectangle(position, 0, 3, h);
561 }
562 }
563
564 // ----------------------------------------------------------------------------
565 // button drawing
566 // ----------------------------------------------------------------------------
567
568 void
569 wxRendererGeneric::DrawComboBoxDropButton(wxWindow *win,
570 wxDC& dc,
571 const wxRect& rect,
572 int flags)
573 {
574 DrawPushButton(win,dc,rect,flags);
575 DrawDropArrow(win,dc,rect,flags);
576 }
577
578 void
579 wxRendererGeneric::DrawDropArrow(wxWindow *win,
580 wxDC& dc,
581 const wxRect& rect,
582 int WXUNUSED(flags))
583 {
584 // This generic implementation should be good
585 // enough for Windows platforms (including XP).
586
587 int arrowHalf = rect.width/5;
588 int rectMid = rect.width / 2;
589 int arrowTopY = (rect.height/2) - (arrowHalf/2);
590
591 // This should always result in arrow with odd width.
592 wxPoint pt[] =
593 {
594 wxPoint(rectMid - arrowHalf, arrowTopY),
595 wxPoint(rectMid + arrowHalf, arrowTopY),
596 wxPoint(rectMid, arrowTopY + arrowHalf)
597 };
598 dc.SetBrush(wxBrush(win->GetForegroundColour()));
599 dc.SetPen(wxPen(win->GetForegroundColour()));
600 dc.DrawPolygon(WXSIZEOF(pt), pt, rect.x, rect.y);
601 }
602
603 void
604 wxRendererGeneric::DrawCheckBox(wxWindow *WXUNUSED(win),
605 wxDC& dc,
606 const wxRect& rect,
607 int flags)
608 {
609 dc.SetPen(*(flags & wxCONTROL_DISABLED ? wxGREY_PEN : wxBLACK_PEN));
610 dc.SetBrush( *wxTRANSPARENT_BRUSH );
611 dc.DrawRectangle(rect);
612
613 if ( flags & wxCONTROL_CHECKED )
614 {
615 dc.DrawCheckMark(rect.Deflate(2, 2));
616 }
617 }
618
619 void
620 wxRendererGeneric::DrawPushButton(wxWindow *win,
621 wxDC& dc,
622 const wxRect& rect,
623 int flags)
624 {
625 // Don't try anything too fancy. It'll just turn out looking
626 // out-of-place on most platforms.
627 wxColour bgCol = flags & wxCONTROL_DISABLED ?
628 wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE) :
629 win->GetBackgroundColour();
630 dc.SetBrush(wxBrush(bgCol));
631 dc.SetPen(wxPen(bgCol));
632 dc.DrawRectangle(rect);
633 }
634
635 void
636 wxRendererGeneric::DrawItemSelectionRect(wxWindow * WXUNUSED(win),
637 wxDC& dc,
638 const wxRect& rect,
639 int flags)
640 {
641 wxBrush brush;
642 if ( flags & wxCONTROL_SELECTED )
643 {
644 if ( flags & wxCONTROL_FOCUSED )
645 {
646 brush = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
647 }
648 else // !focused
649 {
650 brush = wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW));
651 }
652 }
653 else // !selected
654 {
655 brush = *wxTRANSPARENT_BRUSH;
656 }
657
658 dc.SetBrush(brush);
659 dc.SetPen(flags & wxCONTROL_CURRENT ? *wxBLACK_PEN : *wxTRANSPARENT_PEN);
660
661 dc.DrawRectangle( rect );
662 }
663
664
665 // ----------------------------------------------------------------------------
666 // A module to allow cleanup of generic renderer.
667 // ----------------------------------------------------------------------------
668
669 class wxGenericRendererModule: public wxModule
670 {
671 DECLARE_DYNAMIC_CLASS(wxGenericRendererModule)
672 public:
673 wxGenericRendererModule() {}
674 bool OnInit() { return true; }
675 void OnExit() { wxRendererGeneric::Cleanup(); }
676 };
677
678 IMPLEMENT_DYNAMIC_CLASS(wxGenericRendererModule, wxModule)

  ViewVC Help
Powered by ViewVC 1.1.22