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