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