projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Three more attempts to get metal look.
[wxWidgets.git] / src / univ / winuniv.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: univ/window.cpp
3 // Purpose: implementation of extra wxWindow methods for wxUniv port
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 06.08.00
7 // RCS-ID: $Id$
8 // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "univwindow.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/window.h"
34 #include "wx/dcclient.h"
35 #include "wx/dcmemory.h"
36 #include "wx/event.h"
37 #include "wx/scrolbar.h"
38 #include "wx/menu.h"
39 #include "wx/frame.h"
40 #endif // WX_PRECOMP
41
42 #include "wx/univ/colschem.h"
43 #include "wx/univ/renderer.h"
44 #include "wx/univ/theme.h"
45
46 #if wxUSE_CARET
47 #include "wx/caret.h"
48 #endif // wxUSE_CARET
49
50 // turn Refresh() debugging on/off
51 #define WXDEBUG_REFRESH
52
53 #ifndef __WXDEBUG__
54 #undef WXDEBUG_REFRESH
55 #endif
56
57 #if defined(WXDEBUG_REFRESH) && defined(__WXMSW__) && !defined(__WXMICROWIN__)
58 #include "wx/msw/private.h"
59 #endif
60
61 // ============================================================================
62 // implementation
63 // ============================================================================
64
65 // ----------------------------------------------------------------------------
66 // event tables
67 // ----------------------------------------------------------------------------
68
69 // we can't use wxWindowNative here as it won't be expanded inside the macro
70 #if defined(__WXMSW__)
71 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowMSW)
72 #elif defined(__WXGTK__)
73 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowGTK)
74 #elif defined(__WXMGL__)
75 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowMGL)
76 #elif defined(__WXX11__)
77 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowX11)
78 #elif defined(__WXPM__)
79 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowOS2)
80 #endif
81
82 BEGIN_EVENT_TABLE(wxWindow, wxWindowNative)
83 EVT_SIZE(wxWindow::OnSize)
84
85 #if wxUSE_ACCEL || wxUSE_MENUS
86 EVT_KEY_DOWN(wxWindow::OnKeyDown)
87 #endif // wxUSE_ACCEL
88
89 #if wxUSE_MENUS
90 EVT_CHAR(wxWindow::OnChar)
91 EVT_KEY_UP(wxWindow::OnKeyUp)
92 #endif // wxUSE_MENUS
93
94 EVT_PAINT(wxWindow::OnPaint)
95 EVT_NC_PAINT(wxWindow::OnNcPaint)
96 EVT_ERASE_BACKGROUND(wxWindow::OnErase)
97 END_EVENT_TABLE()
98
99 // ----------------------------------------------------------------------------
100 // creation
101 // ----------------------------------------------------------------------------
102
103 void wxWindow::Init()
104 {
105 m_scrollbarVert =
106 m_scrollbarHorz = (wxScrollBar *)NULL;
107
108 m_isCurrent = FALSE;
109
110 m_renderer = wxTheme::Get()->GetRenderer();
111
112 m_oldSize.x = -1;
113 m_oldSize.y = -1;
114 }
115
116 bool wxWindow::Create(wxWindow *parent,
117 wxWindowID id,
118 const wxPoint& pos,
119 const wxSize& size,
120 long style,
121 const wxString& name)
122 {
123 // we add wxCLIP_CHILDREN to get the same ("natural") behaviour under MSW
124 // as under the other platforms
125 if ( !wxWindowNative::Create(parent, id, pos, size,
126 style | wxCLIP_CHILDREN,
127 name) )
128 {
129 return FALSE;
130 }
131
132 // if we should always have the scrollbar, do show it
133 if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
134 {
135 #if wxUSE_TWO_WINDOWS
136 SetInsertIntoMain( TRUE );
137 #endif
138 m_scrollbarVert = new wxScrollBar(this, -1,
139 wxDefaultPosition, wxDefaultSize,
140 wxSB_VERTICAL);
141 #if wxUSE_TWO_WINDOWS
142 SetInsertIntoMain( FALSE );
143 #endif
144
145 // and position it
146 PositionScrollbars();
147 }
148
149 return TRUE;
150 }
151
152 // ----------------------------------------------------------------------------
153 // background pixmap
154 // ----------------------------------------------------------------------------
155
156 void wxWindow::SetBackground(const wxBitmap& bitmap,
157 int alignment,
158 wxStretch stretch)
159 {
160 m_bitmapBg = bitmap;
161 m_alignBgBitmap = alignment;
162 m_stretchBgBitmap = stretch;
163 }
164
165 const wxBitmap& wxWindow::GetBackgroundBitmap(int *alignment,
166 wxStretch *stretch) const
167 {
168 if ( m_bitmapBg.Ok() )
169 {
170 if ( alignment )
171 *alignment = m_alignBgBitmap;
172 if ( stretch )
173 *stretch = m_stretchBgBitmap;
174 }
175
176 return m_bitmapBg;
177 }
178
179 // ----------------------------------------------------------------------------
180 // painting
181 // ----------------------------------------------------------------------------
182
183 // the event handler executed when the window background must be painted
184 void wxWindow::OnErase(wxEraseEvent& event)
185 {
186 if ( !m_renderer )
187 {
188 event.Skip();
189
190 return;
191 }
192
193 DoDrawBackground(*event.GetDC());
194
195 // if we have both scrollbars, we also have a square in the corner between
196 // them which we must paint
197 if ( m_scrollbarVert && m_scrollbarHorz )
198 {
199 wxSize size = GetSize();
200 wxRect rectClient = GetClientRect(),
201 rectBorder = m_renderer->GetBorderDimensions(GetBorder());
202
203 wxRect rectCorner;
204 rectCorner.x = rectClient.GetRight() + 1;
205 rectCorner.y = rectClient.GetBottom() + 1;
206 rectCorner.SetRight(size.x - rectBorder.width);
207 rectCorner.SetBottom(size.y - rectBorder.height);
208
209 if ( GetUpdateRegion().Contains(rectCorner) )
210 {
211 m_renderer->DrawScrollCorner(*event.GetDC(), rectCorner);
212 }
213 }
214 }
215
216 // the event handlers executed when the window must be repainted
217 void wxWindow::OnNcPaint(wxPaintEvent& event)
218 {
219 if ( m_renderer )
220 {
221 // get the window rect
222 wxRect rect;
223 wxSize size = GetSize();
224 rect.x =
225 rect.y = 0;
226 rect.width = size.x;
227 rect.height = size.y;
228
229 // if the scrollbars are outside the border, we must adjust the rect to
230 // exclude them
231 if ( !m_renderer->AreScrollbarsInsideBorder() )
232 {
233 wxScrollBar *scrollbar = GetScrollbar(wxVERTICAL);
234 if ( scrollbar )
235 rect.width -= scrollbar->GetSize().x;
236
237 scrollbar = GetScrollbar(wxHORIZONTAL);
238 if ( scrollbar )
239 rect.height -= scrollbar->GetSize().y;
240 }
241
242 // get the DC and draw the border on it
243 wxWindowDC dc(this);
244 DoDrawBorder(dc, rect);
245 }
246 }
247
248 void wxWindow::OnPaint(wxPaintEvent& event)
249 {
250 if ( !m_renderer )
251 {
252 // it is a native control which paints itself
253 event.Skip();
254 }
255 else
256 {
257 // get the DC to use and create renderer on it
258 wxPaintDC dc(this);
259 wxControlRenderer renderer(this, dc, m_renderer);
260
261 // draw the control
262 DoDraw(&renderer);
263 }
264 }
265
266 bool wxWindow::DoDrawBackground(wxDC& dc)
267 {
268 // FIXME: Leaving this code in leads to partial bg redraws
269 // sometimes under MSW.
270 // The same happens under X11 because it has a clear
271 // region and an update region and these are sometimes
272 // different. RR.
273 wxRect rect;
274 // #ifndef __WXMSW__
275 #if 0
276 rect = GetUpdateRegion().GetBox();
277 if ( !rect.width && !rect.height )
278 #endif
279 {
280 wxSize size = GetSize();
281 rect.width = size.x;
282 rect.height = size.y;
283 }
284
285 if ( GetBackgroundBitmap().Ok() )
286 {
287 // get the bitmap and the flags
288 int alignment;
289 wxStretch stretch;
290 wxBitmap bmp = GetBackgroundBitmap(&alignment, &stretch);
291 wxControlRenderer::DrawBitmap(dc, bmp, rect, alignment, stretch);
292 }
293 else // just fill it with bg colour if no bitmap
294 {
295 m_renderer->DrawBackground(dc, wxTHEME_BG_COLOUR(this),
296 rect, GetStateFlags());
297 }
298
299 return TRUE;
300 }
301
302 void wxWindow::EraseBackground(wxDC& dc, const wxRect& rect)
303 {
304 // TODO: handle bg bitmaps here!
305
306 m_renderer->DrawBackground(dc, wxTHEME_BG_COLOUR(this), rect, GetStateFlags());
307 }
308
309 void wxWindow::DoDrawBorder(wxDC& dc, const wxRect& rect)
310 {
311 // draw outline unless the update region is enitrely inside it in which
312 // case we don't need to do it
313 #if 0 // doesn't seem to work, why?
314 if ( wxRegion(rect).Contains(GetUpdateRegion().GetBox()) != wxInRegion )
315 #endif
316 {
317 m_renderer->DrawBorder(dc, GetBorder(), rect, GetStateFlags());
318 }
319 }
320
321 void wxWindow::DoDraw(wxControlRenderer *renderer)
322 {
323 }
324
325 void wxWindow::Refresh(bool eraseBackground, const wxRect *rectClient)
326 {
327 wxRect rectWin;
328 wxPoint pt = GetClientAreaOrigin();
329
330 wxSize size = GetClientSize();
331
332 if ( rectClient )
333 {
334 rectWin = *rectClient;
335
336 // don't refresh anything beyond the client area (scrollbars for
337 // example)
338 if ( rectWin.GetRight() > size.x )
339 rectWin.SetRight(size.x);
340 if ( rectWin.GetBottom() > size.y )
341 rectWin.SetBottom(size.y);
342
343 rectWin.Offset(pt);
344 }
345 else // refresh the entire client area
346 {
347 rectWin.x = pt.x;
348 rectWin.y = pt.y;
349 rectWin.width = size.x;
350 rectWin.height = size.y;
351 }
352
353 // debugging helper
354 #ifdef WXDEBUG_REFRESH
355 static bool s_refreshDebug = FALSE;
356 if ( s_refreshDebug )
357 {
358 wxWindowDC dc(this);
359 dc.SetBrush(*wxCYAN_BRUSH);
360 dc.SetPen(*wxTRANSPARENT_PEN);
361 dc.DrawRectangle(rectWin);
362
363 // under Unix we use "--sync" X option for this
364 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
365 ::GdiFlush();
366 ::Sleep(200);
367 #endif // __WXMSW__
368 }
369 #endif // WXDEBUG_REFRESH
370
371 wxWindowNative::Refresh(eraseBackground, &rectWin);
372 }
373
374 // ----------------------------------------------------------------------------
375 // state flags
376 // ----------------------------------------------------------------------------
377
378 bool wxWindow::Enable(bool enable)
379 {
380 if ( !wxWindowNative::Enable(enable) )
381 return FALSE;
382
383 // disabled window can't keep focus
384 if ( FindFocus() == this && GetParent() != NULL )
385 {
386 GetParent()->SetFocus();
387 }
388
389 if ( m_renderer )
390 {
391 // a window with renderer is drawn by ourselves and it has to be
392 // refreshed to reflect its new status
393 Refresh();
394 }
395
396 return TRUE;
397 }
398
399 bool wxWindow::IsFocused() const
400 {
401 wxWindow *self = wxConstCast(this, wxWindow);
402 return self->FindFocus() == self;
403 }
404
405 bool wxWindow::IsPressed() const
406 {
407 return FALSE;
408 }
409
410 bool wxWindow::IsDefault() const
411 {
412 return FALSE;
413 }
414
415 bool wxWindow::IsCurrent() const
416 {
417 return m_isCurrent;
418 }
419
420 bool wxWindow::SetCurrent(bool doit)
421 {
422 if ( doit == m_isCurrent )
423 return FALSE;
424
425 m_isCurrent = doit;
426
427 if ( CanBeHighlighted() )
428 Refresh();
429
430 return TRUE;
431 }
432
433 int wxWindow::GetStateFlags() const
434 {
435 int flags = 0;
436 if ( !IsEnabled() )
437 flags |= wxCONTROL_DISABLED;
438
439 // the following states are only possible if our application is active - if
440 // it is not, even our default/focused controls shouldn't appear as such
441 if ( wxTheApp->IsActive() )
442 {
443 if ( IsCurrent() )
444 flags |= wxCONTROL_CURRENT;
445 if ( IsFocused() )
446 flags |= wxCONTROL_FOCUSED;
447 if ( IsPressed() )
448 flags |= wxCONTROL_PRESSED;
449 if ( IsDefault() )
450 flags |= wxCONTROL_ISDEFAULT;
451 }
452
453 return flags;
454 }
455
456 // ----------------------------------------------------------------------------
457 // size
458 // ----------------------------------------------------------------------------
459
460 void wxWindow::OnSize(wxSizeEvent& event)
461 {
462 event.Skip();
463
464 if ( m_scrollbarVert || m_scrollbarHorz )
465 {
466 PositionScrollbars();
467 }
468
469 #if 0 // ndef __WXMSW__
470 // Refresh the area (strip) previously occupied by the border
471
472 if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) && IsShown())
473 {
474 // This code assumes that wxSizeEvent.GetSize() returns
475 // the area of the entire window, not just the client
476 // area.
477 wxSize newSize = event.GetSize();
478
479 if (m_oldSize.x == -1 && m_oldSize.y == -1)
480 {
481 m_oldSize = newSize;
482 return;
483 }
484
485 if (HasFlag( wxSIMPLE_BORDER ))
486 {
487 if (newSize.y > m_oldSize.y)
488 {
489 wxRect rect;
490 rect.x = 0;
491 rect.width = m_oldSize.x;
492 rect.y = m_oldSize.y-2;
493 rect.height = 1;
494 Refresh( TRUE, &rect );
495 }
496 else if (newSize.y < m_oldSize.y)
497 {
498 wxRect rect;
499 rect.y = newSize.y;
500 rect.x = 0;
501 rect.height = 1;
502 rect.width = newSize.x;
503 wxWindowNative::Refresh( TRUE, &rect );
504 }
505
506 if (newSize.x > m_oldSize.x)
507 {
508 wxRect rect;
509 rect.y = 0;
510 rect.height = m_oldSize.y;
511 rect.x = m_oldSize.x-2;
512 rect.width = 1;
513 Refresh( TRUE, &rect );
514 }
515 else if (newSize.x < m_oldSize.x)
516 {
517 wxRect rect;
518 rect.x = newSize.x;
519 rect.y = 0;
520 rect.width = 1;
521 rect.height = newSize.y;
522 wxWindowNative::Refresh( TRUE, &rect );
523 }
524 }
525 else
526 if (HasFlag( wxSUNKEN_BORDER ) || HasFlag( wxRAISED_BORDER ))
527 {
528 if (newSize.y > m_oldSize.y)
529 {
530 wxRect rect;
531 rect.x = 0;
532 rect.width = m_oldSize.x;
533 rect.y = m_oldSize.y-4;
534 rect.height = 2;
535 Refresh( TRUE, &rect );
536 }
537 else if (newSize.y < m_oldSize.y)
538 {
539 wxRect rect;
540 rect.y = newSize.y;
541 rect.x = 0;
542 rect.height = 2;
543 rect.width = newSize.x;
544 wxWindowNative::Refresh( TRUE, &rect );
545 }
546
547 if (newSize.x > m_oldSize.x)
548 {
549 wxRect rect;
550 rect.y = 0;
551 rect.height = m_oldSize.y;
552 rect.x = m_oldSize.x-4;
553 rect.width = 2;
554 Refresh( TRUE, &rect );
555 }
556 else if (newSize.x < m_oldSize.x)
557 {
558 wxRect rect;
559 rect.x = newSize.x;
560 rect.y = 0;
561 rect.width = 2;
562 rect.height = newSize.y;
563 wxWindowNative::Refresh( TRUE, &rect );
564 }
565 }
566
567 m_oldSize = newSize;
568 }
569 #endif
570 }
571
572 wxSize wxWindow::DoGetBestSize() const
573 {
574 return AdjustSize(DoGetBestClientSize());
575 }
576
577 wxSize wxWindow::DoGetBestClientSize() const
578 {
579 return wxWindowNative::DoGetBestSize();
580 }
581
582 wxSize wxWindow::AdjustSize(const wxSize& size) const
583 {
584 wxSize sz = size;
585 if ( m_renderer )
586 m_renderer->AdjustSize(&sz, this);
587 return sz;
588 }
589
590 wxPoint wxWindow::GetClientAreaOrigin() const
591 {
592 wxPoint pt = wxWindowBase::GetClientAreaOrigin();
593
594 #if wxUSE_TWO_WINDOWS
595 #else
596 if ( m_renderer )
597 pt += m_renderer->GetBorderDimensions(GetBorder()).GetPosition();
598 #endif
599
600 return pt;
601 }
602
603 void wxWindow::DoGetClientSize(int *width, int *height) const
604 {
605 // if it is a native window, we assume it handles the scrollbars itself
606 // too - and if it doesn't, there is not much we can do
607 if ( !m_renderer )
608 {
609 wxWindowNative::DoGetClientSize(width, height);
610
611 return;
612 }
613
614 int w, h;
615 wxWindowNative::DoGetClientSize(&w, &h);
616
617 // we assume that the scrollbars are positioned correctly (by a previous
618 // call to PositionScrollbars()) here
619
620 wxRect rectBorder;
621 if ( m_renderer )
622 rectBorder = m_renderer->GetBorderDimensions(GetBorder());
623
624 bool inside = m_renderer->AreScrollbarsInsideBorder();
625
626 if ( width )
627 {
628 // in any case, take account of the scrollbar
629 if ( m_scrollbarVert )
630 w -= m_scrollbarVert->GetSize().x;
631
632 // if we don't have scrollbar or if it is outside the border (and not
633 // blended into it), take account of the right border as well
634 if ( !m_scrollbarVert || inside )
635 w -= rectBorder.width;
636
637 // and always account for the left border
638 *width = w - rectBorder.x;
639
640 // we shouldn't return invalid width
641 if ( *width < 0 )
642 *width = 0;
643 }
644
645 if ( height )
646 {
647 if ( m_scrollbarHorz )
648 h -= m_scrollbarHorz->GetSize().y;
649
650 if ( !m_scrollbarHorz || inside )
651 h -= rectBorder.height;
652
653 *height = h - rectBorder.y;
654
655 // we shouldn't return invalid height
656 if ( *height < 0 )
657 *height = 0;
658 }
659 }
660
661 void wxWindow::DoSetClientSize(int width, int height)
662 {
663 // take into account the borders
664 wxRect rectBorder = m_renderer->GetBorderDimensions(GetBorder());
665 width += rectBorder.x;
666 height += rectBorder.y;
667
668 // and the scrollbars (as they may be offset into the border, use the
669 // scrollbar position, not size - this supposes that PositionScrollbars()
670 // had been called before)
671 bool inside = m_renderer->AreScrollbarsInsideBorder();
672 wxSize size = GetSize();
673 if ( m_scrollbarVert )
674 width += size.x - m_scrollbarVert->GetPosition().x;
675 if ( !m_scrollbarVert || inside )
676 width += rectBorder.width;
677
678 if ( m_scrollbarHorz )
679 height += size.y - m_scrollbarHorz->GetPosition().y;
680 if ( !m_scrollbarHorz || inside )
681 height += rectBorder.height;
682
683 wxWindowNative::DoSetClientSize(width, height);
684 }
685
686 wxHitTest wxWindow::DoHitTest(wxCoord x, wxCoord y) const
687 {
688 wxHitTest ht = wxWindowNative::DoHitTest(x, y);
689 if ( ht == wxHT_WINDOW_INSIDE )
690 {
691 if ( m_scrollbarVert && x >= m_scrollbarVert->GetPosition().x )
692 {
693 // it can still be changed below because it may also be the corner
694 ht = wxHT_WINDOW_VERT_SCROLLBAR;
695 }
696
697 if ( m_scrollbarHorz && y >= m_scrollbarHorz->GetPosition().y )
698 {
699 ht = ht == wxHT_WINDOW_VERT_SCROLLBAR ? wxHT_WINDOW_CORNER
700 : wxHT_WINDOW_HORZ_SCROLLBAR;
701 }
702 }
703
704 return ht;
705 }
706
707 // ----------------------------------------------------------------------------
708 // scrolling: we implement it entirely ourselves except for ScrollWindow()
709 // function which is supposed to be (efficiently) implemented by the native
710 // window class
711 // ----------------------------------------------------------------------------
712
713 void wxWindow::RefreshScrollbars()
714 {
715 if ( m_scrollbarHorz )
716 m_scrollbarHorz->Refresh();
717
718 if ( m_scrollbarVert )
719 m_scrollbarVert->Refresh();
720 }
721
722 void wxWindow::PositionScrollbars()
723 {
724 // do not use GetClientSize/Rect as it relies on the scrollbars being
725 // correctly positioned
726
727 wxSize size = GetSize();
728 wxBorder border = GetBorder();
729 wxRect rectBorder = m_renderer->GetBorderDimensions(border);
730 bool inside = m_renderer->AreScrollbarsInsideBorder();
731
732 int height = m_scrollbarHorz ? m_scrollbarHorz->GetSize().y : 0;
733 int width = m_scrollbarVert ? m_scrollbarVert->GetSize().x : 0;
734
735 wxRect rectBar;
736 if ( m_scrollbarVert )
737 {
738 rectBar.x = size.x - width;
739 if ( inside )
740 rectBar.x -= rectBorder.width;
741 rectBar.width = width;
742 rectBar.y = 0;
743 if ( inside )
744 rectBar.y += rectBorder.y;
745 rectBar.height = size.y - height;
746 if ( inside )
747 rectBar.height -= rectBorder.y + rectBorder.height;
748
749 m_scrollbarVert->SetSize(rectBar, wxSIZE_NO_ADJUSTMENTS);
750 }
751
752 if ( m_scrollbarHorz )
753 {
754 rectBar.y = size.y - height;
755 if ( inside )
756 rectBar.y -= rectBorder.height;
757 rectBar.height = height;
758 rectBar.x = 0;
759 if ( inside )
760 rectBar.x += rectBorder.x;
761 rectBar.width = size.x - width;
762 if ( inside )
763 rectBar.width -= rectBorder.x + rectBorder.width;
764
765 m_scrollbarHorz->SetSize(rectBar, wxSIZE_NO_ADJUSTMENTS);
766 }
767
768 RefreshScrollbars();
769 }
770
771 void wxWindow::SetScrollbar(int orient,
772 int pos,
773 int pageSize,
774 int range,
775 bool refresh)
776 {
777 wxASSERT_MSG( pageSize <= range,
778 _T("page size can't be greater than range") );
779
780 bool hasClientSizeChanged = FALSE;
781 wxScrollBar *scrollbar = GetScrollbar(orient);
782 if ( range && (pageSize < range) )
783 {
784 if ( !scrollbar )
785 {
786 // create it
787 #if wxUSE_TWO_WINDOWS
788 SetInsertIntoMain( TRUE );
789 #endif
790 scrollbar = new wxScrollBar(this, -1,
791 wxDefaultPosition, wxDefaultSize,
792 orient & wxVERTICAL ? wxSB_VERTICAL
793 : wxSB_HORIZONTAL);
794 #if wxUSE_TWO_WINDOWS
795 SetInsertIntoMain( FALSE );
796 #endif
797 if ( orient & wxVERTICAL )
798 m_scrollbarVert = scrollbar;
799 else
800 m_scrollbarHorz = scrollbar;
801
802 // the client area diminished as we created a scrollbar
803 hasClientSizeChanged = TRUE;
804
805 PositionScrollbars();
806 }
807 else if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
808 {
809 // we might have disabled it before
810 scrollbar->Enable();
811 }
812
813 scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
814 }
815 else // no range means no scrollbar
816 {
817 if ( scrollbar )
818 {
819 // wxALWAYS_SHOW_SB only applies to the vertical scrollbar
820 if ( (orient & wxVERTICAL) && (GetWindowStyle() & wxALWAYS_SHOW_SB) )
821 {
822 // just disable the scrollbar
823 scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
824 scrollbar->Disable();
825 }
826 else // really remove the scrollbar
827 {
828 delete scrollbar;
829
830 if ( orient & wxVERTICAL )
831 m_scrollbarVert = NULL;
832 else
833 m_scrollbarHorz = NULL;
834
835 // the client area increased as we removed a scrollbar
836 hasClientSizeChanged = TRUE;
837
838 // the size of the remaining scrollbar must be adjusted
839 if ( m_scrollbarHorz || m_scrollbarVert )
840 {
841 PositionScrollbars();
842 }
843 }
844 }
845 }
846
847 // give the window a chance to relayout
848 if ( hasClientSizeChanged )
849 {
850 #if wxUSE_TWO_WINDOWS
851 wxWindowNative::SetSize( GetSize() );
852 #else
853 wxSizeEvent event(GetSize());
854 (void)GetEventHandler()->ProcessEvent(event);
855 #endif
856 }
857 }
858
859 void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
860 {
861 wxScrollBar *scrollbar = GetScrollbar(orient);
862 wxCHECK_RET( scrollbar, _T("no scrollbar to set position for") );
863
864 scrollbar->SetThumbPosition(pos);
865
866 // VZ: I think we can safely ignore this as we always refresh it
867 // automatically whenever the value chanegs
868 #if 0
869 if ( refresh )
870 Refresh();
871 #endif
872 }
873
874 int wxWindow::GetScrollPos(int orient) const
875 {
876 wxScrollBar *scrollbar = GetScrollbar(orient);
877 return scrollbar ? scrollbar->GetThumbPosition() : 0;
878 }
879
880 int wxWindow::GetScrollThumb(int orient) const
881 {
882 wxScrollBar *scrollbar = GetScrollbar(orient);
883 return scrollbar ? scrollbar->GetThumbSize() : 0;
884 }
885
886 int wxWindow::GetScrollRange(int orient) const
887 {
888 wxScrollBar *scrollbar = GetScrollbar(orient);
889 return scrollbar ? scrollbar->GetRange() : 0;
890 }
891
892 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
893 {
894 // use native scrolling when available and do it in generic way
895 // otherwise:
896 #ifdef __WXX11__
897
898 wxWindowNative::ScrollWindow(dx, dy, rect);
899
900 #else
901
902 // before scrolling it, ensure that we don't have any unpainted areas
903 Update();
904
905 wxRect r;
906
907 if ( dx )
908 {
909 r = ScrollNoRefresh(dx, 0, rect);
910 Refresh(TRUE /* erase bkgnd */, &r);
911 }
912
913 if ( dy )
914 {
915 r = ScrollNoRefresh(0, dy, rect);
916 Refresh(TRUE /* erase bkgnd */, &r);
917 }
918
919 // scroll children accordingly:
920 wxPoint offset(dx, dy);
921
922 for (wxWindowList::Node *node = GetChildren().GetFirst();
923 node; node = node->GetNext())
924 {
925 wxWindow *child = node->GetData();
926 if ( child == m_scrollbarVert || child == m_scrollbarHorz )
927 continue;
928
929 // VS: Scrolling children has non-trivial semantics. If rect=NULL then
930 // it is easy: we scroll all children. Otherwise it gets
931 // complicated:
932 // 1. if scrolling in one direction only, scroll only
933 // those children that intersect shaft defined by the rectangle
934 // and scrolling direction
935 // 2. if scrolling in both axes, scroll all children
936
937 if ( rect && (dx * dy == 0 /* moving in only one of x, y axis */) )
938 {
939 wxRect childRect = child->GetRect();
940 if ( dx == 0 && (childRect.GetLeft() <= rect->GetRight() ||
941 childRect.GetRight() >= rect->GetLeft()) )
942 {
943 child->Move(child->GetPosition() + offset);
944 }
945 else if ( dy == 0 && (childRect.GetTop() <= rect->GetBottom() ||
946 childRect.GetBottom() >= rect->GetTop()) )
947 {
948 child->Move(child->GetPosition() + offset);
949 }
950 }
951 else
952 {
953 child->Move(child->GetPosition() + offset);
954 }
955 }
956 #endif
957 }
958
959 wxRect wxWindow::ScrollNoRefresh(int dx, int dy, const wxRect *rectTotal)
960 {
961 wxASSERT_MSG( !dx || !dy, _T("can't be used for diag scrolling") );
962
963 // the rect to refresh (which we will calculate)
964 wxRect rect;
965
966 if ( !dx && !dy )
967 {
968 // nothing to do
969 return rect;
970 }
971
972 // calculate the part of the window which we can just redraw in the new
973 // location
974 wxSize sizeTotal = rectTotal ? rectTotal->GetSize() : GetClientSize();
975
976 wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
977 sizeTotal.x, sizeTotal.y, dx, dy);
978
979 // the initial and end point of the region we move in client coords
980 wxPoint ptSource, ptDest;
981 if ( rectTotal )
982 {
983 ptSource = rectTotal->GetPosition();
984 ptDest = rectTotal->GetPosition();
985 }
986
987 // the size of this region
988 wxSize size;
989 size.x = sizeTotal.x - abs(dx);
990 size.y = sizeTotal.y - abs(dy);
991 if ( size.x <= 0 || size.y <= 0 )
992 {
993 // just redraw everything as nothing of the displayed image will stay
994 wxLogTrace(_T("scroll"), _T("refreshing everything"));
995
996 rect = rectTotal ? *rectTotal : wxRect(0, 0, sizeTotal.x, sizeTotal.y);
997 }
998 else // move the part which doesn't change to the new location
999 {
1000 // note that when we scroll the canvas in some direction we move the
1001 // block which doesn't need to be refreshed in the opposite direction
1002
1003 if ( dx < 0 )
1004 {
1005 // scroll to the right, move to the left
1006 ptSource.x -= dx;
1007 }
1008 else
1009 {
1010 // scroll to the left, move to the right
1011 ptDest.x += dx;
1012 }
1013
1014 if ( dy < 0 )
1015 {
1016 // scroll down, move up
1017 ptSource.y -= dy;
1018 }
1019 else
1020 {
1021 // scroll up, move down
1022 ptDest.y += dy;
1023 }
1024
1025 #if wxUSE_CARET
1026 // we need to hide the caret before moving or it will erase itself at
1027 // the wrong (old) location
1028 wxCaret *caret = GetCaret();
1029 if ( caret )
1030 caret->Hide();
1031 #endif // wxUSE_CARET
1032
1033 // do move
1034 wxClientDC dc(this);
1035 wxBitmap bmp(size.x, size.y);
1036 wxMemoryDC dcMem;
1037 dcMem.SelectObject(bmp);
1038
1039 dcMem.Blit(wxPoint(0, 0), size, &dc, ptSource
1040 #if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
1041 + GetClientAreaOrigin()
1042 #endif // broken wxGTK wxDC::Blit
1043 );
1044 dc.Blit(ptDest, size, &dcMem, wxPoint(0, 0));
1045
1046 wxLogTrace(_T("scroll"),
1047 _T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
1048 ptSource.x, ptSource.y,
1049 size.x, size.y,
1050 ptDest.x, ptDest.y);
1051
1052 // and now repaint the uncovered area
1053
1054 // FIXME: We repaint the intersection of these rectangles twice - is
1055 // it bad? I don't think so as it is rare to scroll the window
1056 // diagonally anyhow and so adding extra logic to compute
1057 // rectangle intersection is probably not worth the effort
1058
1059 rect.x = ptSource.x;
1060 rect.y = ptSource.y;
1061
1062 if ( dx )
1063 {
1064 if ( dx < 0 )
1065 {
1066 // refresh the area along the right border
1067 rect.x += size.x + dx;
1068 rect.width = -dx;
1069 }
1070 else
1071 {
1072 // refresh the area along the left border
1073 rect.width = dx;
1074 }
1075
1076 rect.height = sizeTotal.y;
1077
1078 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
1079 rect.x, rect.y,
1080 rect.GetRight() + 1, rect.GetBottom() + 1);
1081 }
1082
1083 if ( dy )
1084 {
1085 if ( dy < 0 )
1086 {
1087 // refresh the area along the bottom border
1088 rect.y += size.y + dy;
1089 rect.height = -dy;
1090 }
1091 else
1092 {
1093 // refresh the area along the top border
1094 rect.height = dy;
1095 }
1096
1097 rect.width = sizeTotal.x;
1098
1099 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
1100 rect.x, rect.y,
1101 rect.GetRight() + 1, rect.GetBottom() + 1);
1102 }
1103
1104 #if wxUSE_CARET
1105 if ( caret )
1106 caret->Show();
1107 #endif // wxUSE_CARET
1108 }
1109
1110 return rect;
1111 }
1112
1113 // ----------------------------------------------------------------------------
1114 // accelerators and menu hot keys
1115 // ----------------------------------------------------------------------------
1116
1117 #if wxUSE_MENUS
1118 // the last window over which Alt was pressed (used by OnKeyUp)
1119 wxWindow *wxWindow::ms_winLastAltPress = NULL;
1120 #endif // wxUSE_MENUS
1121
1122 #if wxUSE_ACCEL || wxUSE_MENUS
1123
1124 void wxWindow::OnKeyDown(wxKeyEvent& event)
1125 {
1126 #if wxUSE_MENUS
1127 int key = event.GetKeyCode();
1128 if ( !event.ControlDown() && (key == WXK_MENU || key == WXK_F10) )
1129 {
1130 ms_winLastAltPress = this;
1131
1132 // it can't be an accel anyhow
1133 return;
1134 }
1135
1136 ms_winLastAltPress = NULL;
1137 #endif // wxUSE_MENUS
1138
1139 #if wxUSE_ACCEL
1140 for ( wxWindow *win = this; win; win = win->GetParent() )
1141 {
1142 int command = win->GetAcceleratorTable()->GetCommand(event);
1143 if ( command != -1 )
1144 {
1145 wxCommandEvent eventCmd(wxEVT_COMMAND_MENU_SELECTED, command);
1146 if ( win->GetEventHandler()->ProcessEvent(eventCmd) )
1147 {
1148 // skip "event.Skip()" below
1149 return;
1150 }
1151 }
1152
1153 if ( win->IsTopLevel() )
1154 {
1155 // try the frame menu bar
1156 #if wxUSE_MENUS
1157 wxFrame *frame = wxDynamicCast(win, wxFrame);
1158 if ( frame )
1159 {
1160 wxMenuBar *menubar = frame->GetMenuBar();
1161 if ( menubar && menubar->ProcessAccelEvent(event) )
1162 {
1163 // skip "event.Skip()" below
1164 return;
1165 }
1166 }
1167 #endif // wxUSE_MENUS
1168
1169 // if it wasn't in a menu, try to find a button
1170 if ( command != -1 )
1171 {
1172 wxWindow* child = win->FindWindow(command);
1173 if ( child && wxDynamicCast(child, wxButton) )
1174 {
1175 wxCommandEvent eventCmd(wxEVT_COMMAND_BUTTON_CLICKED, command);
1176 eventCmd.SetEventObject(child);
1177 if ( child->GetEventHandler()->ProcessEvent(eventCmd) )
1178 {
1179 // skip "event.Skip()" below
1180 return;
1181 }
1182 }
1183 }
1184
1185 // don't propagate accels from the child frame to the parent one
1186 break;
1187 }
1188 }
1189 #endif // wxUSE_ACCEL
1190
1191 event.Skip();
1192 }
1193
1194 #endif // wxUSE_ACCEL
1195
1196 #if wxUSE_MENUS
1197
1198 wxMenuBar *wxWindow::GetParentFrameMenuBar() const
1199 {
1200 for ( const wxWindow *win = this; win; win = win->GetParent() )
1201 {
1202 if ( win->IsTopLevel() )
1203 {
1204 wxFrame *frame = wxDynamicCast(win, wxFrame);
1205 if ( frame )
1206 {
1207 return frame->GetMenuBar();
1208 }
1209
1210 // don't look further - we don't want to return the menubar of the
1211 // parent frame
1212 break;
1213 }
1214 }
1215
1216 return NULL;
1217 }
1218
1219 void wxWindow::OnChar(wxKeyEvent& event)
1220 {
1221 if ( event.AltDown() && !event.ControlDown() )
1222 {
1223 int key = event.GetKeyCode();
1224
1225 wxMenuBar *menubar = GetParentFrameMenuBar();
1226 if ( menubar )
1227 {
1228 int item = menubar->FindNextItemForAccel(-1, key);
1229 if ( item != -1 )
1230 {
1231 menubar->PopupMenu((size_t)item);
1232
1233 // skip "event.Skip()" below
1234 return;
1235 }
1236 }
1237 }
1238
1239 event.Skip();
1240 }
1241
1242 void wxWindow::OnKeyUp(wxKeyEvent& event)
1243 {
1244 int key = event.GetKeyCode();
1245 if ( !event.HasModifiers() && (key == WXK_MENU || key == WXK_F10) )
1246 {
1247 // only process Alt release specially if there were no other key
1248 // presses since Alt had been pressed and if both events happened in
1249 // the same window
1250 if ( ms_winLastAltPress == this )
1251 {
1252 wxMenuBar *menubar = GetParentFrameMenuBar();
1253 if ( menubar && this != menubar )
1254 {
1255 menubar->SelectMenu(0);
1256 }
1257 }
1258 }
1259 else
1260 {
1261 event.Skip();
1262 }
1263
1264 // in any case reset it
1265 ms_winLastAltPress = NULL;
1266 }
1267
1268 #endif // wxUSE_MENUS
1269
1270 // ----------------------------------------------------------------------------
1271 // MSW-specific section
1272 // ----------------------------------------------------------------------------
1273
1274 #ifdef __WXMSW__
1275
1276 #include "wx/msw/private.h"
1277
1278 long wxWindow::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1279 {
1280 if ( message == WM_NCHITTEST )
1281 {
1282 // the windows which contain the other windows should let the mouse
1283 // events through, otherwise a window inside a static box would
1284 // never get any events at all
1285 if ( IsStaticBox() )
1286 {
1287 return HTTRANSPARENT;
1288 }
1289 }
1290
1291 return wxWindowNative::MSWWindowProc(message, wParam, lParam);
1292 }
1293
1294 #endif // __WXMSW__
1295
wxWidgets (Impactor)