]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/univ/winuniv.cpp
fixed crash in wxRegion::Empty
[wxWidgets.git] / src / univ / winuniv.cpp
... / ...
CommitLineData
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
74BEGIN_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)
89END_EVENT_TABLE()
90
91// ----------------------------------------------------------------------------
92// creation
93// ----------------------------------------------------------------------------
94
95void 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
105bool 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
145void 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
154const 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
173void 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
206void 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
237void 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
255bool 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
287void 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
294void 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
306void wxWindow::DoDraw(wxControlRenderer *renderer)
307{
308}
309
310void 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
363bool 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
384bool wxWindow::IsFocused() const
385{
386 wxWindow *self = wxConstCast(this, wxWindow);
387 return self->FindFocus() == self;
388}
389
390bool wxWindow::IsPressed() const
391{
392 return FALSE;
393}
394
395bool wxWindow::IsDefault() const
396{
397 return FALSE;
398}
399
400bool wxWindow::IsCurrent() const
401{
402 return m_isCurrent;
403}
404
405bool 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
418int 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
445void wxWindow::OnSize(wxSizeEvent& event)
446{
447 if ( m_scrollbarVert || m_scrollbarHorz )
448 {
449 PositionScrollbars();
450 }
451
452 event.Skip();
453}
454
455wxSize wxWindow::DoGetBestSize() const
456{
457 return AdjustSize(DoGetBestClientSize());
458}
459
460wxSize wxWindow::DoGetBestClientSize() const
461{
462 return wxWindowNative::DoGetBestSize();
463}
464
465wxSize 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
473wxPoint 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
483void 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
541void 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
566wxHitTest 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
593void wxWindow::RefreshScrollbars()
594{
595 if ( m_scrollbarHorz )
596 m_scrollbarHorz->Refresh();
597
598 if ( m_scrollbarVert )
599 m_scrollbarVert->Refresh();
600}
601
602void 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
651void 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
726void 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
733 // VZ: I think we can safely ignore this as we always refresh it
734 // automatically whenever the value chanegs
735#if 0
736 if ( refresh )
737 Refresh();
738#endif
739}
740
741int wxWindow::GetScrollPos(int orient) const
742{
743 wxScrollBar *scrollbar = GetScrollbar(orient);
744 return scrollbar ? scrollbar->GetThumbPosition() : 0;
745}
746
747int wxWindow::GetScrollThumb(int orient) const
748{
749 wxScrollBar *scrollbar = GetScrollbar(orient);
750 return scrollbar ? scrollbar->GetThumbSize() : 0;
751}
752
753int wxWindow::GetScrollRange(int orient) const
754{
755 wxScrollBar *scrollbar = GetScrollbar(orient);
756 return scrollbar ? scrollbar->GetRange() : 0;
757}
758
759void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
760{
761 // before scrolling it, ensure that we don't have any unpainted areas
762 Update();
763
764 wxRect r;
765
766 if ( dx )
767 {
768 r = ScrollNoRefresh(dx, 0, rect);
769 Refresh(TRUE /* erase bkgnd */, &r);
770 }
771
772 if ( dy )
773 {
774 r = ScrollNoRefresh(0, dy, rect);
775 Refresh(TRUE /* erase bkgnd */, &r);
776 }
777}
778
779wxRect wxWindow::ScrollNoRefresh(int dx, int dy, const wxRect *rectTotal)
780{
781 wxASSERT_MSG( !dx || !dy, _T("can't be used for diag scrolling") );
782
783 // the rect to refresh (which we will calculate)
784 wxRect rect;
785
786 if ( !dx && !dy )
787 {
788 // nothing to do
789 return rect;
790 }
791
792 // calculate the part of the window which we can just redraw in the new
793 // location
794 wxSize sizeTotal = rectTotal ? rectTotal->GetSize() : GetClientSize();
795
796 wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
797 sizeTotal.x, sizeTotal.y, dx, dy);
798
799 // the initial and end point of the region we move in client coords
800 wxPoint ptSource, ptDest;
801 if ( rectTotal )
802 {
803 ptSource = rectTotal->GetPosition();
804 ptDest = rectTotal->GetPosition();
805 }
806
807 // the size of this region
808 wxSize size;
809 size.x = sizeTotal.x - abs(dx);
810 size.y = sizeTotal.y - abs(dy);
811 if ( size.x <= 0 || size.y <= 0 )
812 {
813 // just redraw everything as nothing of the displayed image will stay
814 wxLogTrace(_T("scroll"), _T("refreshing everything"));
815
816 rect = rectTotal ? *rectTotal : wxRect(0, 0, sizeTotal.x, sizeTotal.y);
817 }
818 else // move the part which doesn't change to the new location
819 {
820 // note that when we scroll the canvas in some direction we move the
821 // block which doesn't need to be refreshed in the opposite direction
822
823 if ( dx < 0 )
824 {
825 // scroll to the right, move to the left
826 ptSource.x -= dx;
827 }
828 else
829 {
830 // scroll to the left, move to the right
831 ptDest.x += dx;
832 }
833
834 if ( dy < 0 )
835 {
836 // scroll down, move up
837 ptSource.y -= dy;
838 }
839 else
840 {
841 // scroll up, move down
842 ptDest.y += dy;
843 }
844
845#if wxUSE_CARET
846 // we need to hide the caret before moving or it will erase itself at
847 // the wrong (old) location
848 wxCaret *caret = GetCaret();
849 if ( caret )
850 caret->Hide();
851#endif // wxUSE_CARET
852
853 // do move
854 wxClientDC dc(this);
855 wxBitmap bmp(size.x, size.y);
856 wxMemoryDC dcMem;
857 dcMem.SelectObject(bmp);
858
859 dcMem.Blit(wxPoint(0, 0), size, &dc, ptSource
860#if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
861 + GetClientAreaOrigin()
862#endif // broken wxGTK wxDC::Blit
863 );
864 dc.Blit(ptDest, size, &dcMem, wxPoint(0, 0));
865
866 wxLogTrace(_T("scroll"),
867 _T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
868 ptSource.x, ptSource.y,
869 size.x, size.y,
870 ptDest.x, ptDest.y);
871
872 // and now repaint the uncovered area
873
874 // FIXME: We repaint the intersection of these rectangles twice - is
875 // it bad? I don't think so as it is rare to scroll the window
876 // diagonally anyhow and so adding extra logic to compute
877 // rectangle intersection is probably not worth the effort
878
879 rect.x = ptSource.x;
880 rect.y = ptSource.y;
881
882 if ( dx )
883 {
884 if ( dx < 0 )
885 {
886 // refresh the area along the right border
887 rect.x += size.x + dx;
888 rect.width = -dx;
889 }
890 else
891 {
892 // refresh the area along the left border
893 rect.width = dx;
894 }
895
896 rect.height = sizeTotal.y;
897
898 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
899 rect.x, rect.y,
900 rect.GetRight() + 1, rect.GetBottom() + 1);
901 }
902
903 if ( dy )
904 {
905 if ( dy < 0 )
906 {
907 // refresh the area along the bottom border
908 rect.y += size.y + dy;
909 rect.height = -dy;
910 }
911 else
912 {
913 // refresh the area along the top border
914 rect.height = dy;
915 }
916
917 rect.width = sizeTotal.x;
918
919 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
920 rect.x, rect.y,
921 rect.GetRight() + 1, rect.GetBottom() + 1);
922 }
923
924#if wxUSE_CARET
925 if ( caret )
926 caret->Show();
927#endif // wxUSE_CARET
928 }
929
930 return rect;
931}
932
933// ----------------------------------------------------------------------------
934// colours/fonts
935// ----------------------------------------------------------------------------
936
937bool wxWindow::SetBackgroundColour(const wxColour& colour)
938{
939 if ( !wxWindowNative::SetBackgroundColour(colour) )
940 return FALSE;
941
942 m_hasBgCol = TRUE;
943
944 return TRUE;
945}
946
947bool wxWindow::SetForegroundColour(const wxColour& colour)
948{
949 if ( !wxWindowNative::SetForegroundColour(colour) )
950 return FALSE;
951
952 m_hasFgCol = TRUE;
953
954 return TRUE;
955}
956
957bool wxWindow::SetFont(const wxFont& font)
958{
959 if ( !wxWindowNative::SetFont(font) )
960 return FALSE;
961
962 m_hasFont = TRUE;
963
964 return TRUE;
965}
966
967// ----------------------------------------------------------------------------
968// mouse capture
969// ----------------------------------------------------------------------------
970
971struct WXDLLEXPORT wxWindowNext
972{
973 wxWindow *win;
974 wxWindowNext *next;
975} *wxWindow::ms_winCaptureNext = NULL;
976
977void wxWindow::CaptureMouse()
978{
979 wxWindow *winOld = GetCapture();
980 if ( winOld )
981 {
982 // save it on stack
983 wxWindowNext *item = new wxWindowNext;
984 item->win = winOld;
985 item->next = ms_winCaptureNext;
986 ms_winCaptureNext = item;
987 }
988 //else: no mouse capture to save
989
990 wxWindowNative::CaptureMouse();
991}
992
993void wxWindow::ReleaseMouse()
994{
995 wxWindowNative::ReleaseMouse();
996
997 if ( ms_winCaptureNext )
998 {
999 ms_winCaptureNext->win->CaptureMouse();
1000
1001 wxWindowNext *item = ms_winCaptureNext;
1002 ms_winCaptureNext = item->next;
1003 delete item;
1004 }
1005 //else: stack is empty, no previous capture
1006}
1007
1008// ----------------------------------------------------------------------------
1009// accelerators and menu hot keys
1010// ----------------------------------------------------------------------------
1011
1012#if wxUSE_MENUS
1013 // the last window over which Alt was pressed (used by OnKeyUp)
1014 wxWindow *wxWindow::ms_winLastAltPress = NULL;
1015#endif // wxUSE_MENUS
1016
1017#if wxUSE_ACCEL || wxUSE_MENUS
1018
1019void wxWindow::OnKeyDown(wxKeyEvent& event)
1020{
1021#if wxUSE_MENUS
1022 int key = event.GetKeyCode();
1023 if ( !event.ControlDown() && (key == WXK_MENU || key == WXK_F10) )
1024 {
1025 ms_winLastAltPress = this;
1026
1027 // it can't be an accel anyhow
1028 return;
1029 }
1030
1031 ms_winLastAltPress = NULL;
1032#endif // wxUSE_MENUS
1033
1034#if wxUSE_ACCEL
1035 for ( wxWindow *win = this; win; win = win->GetParent() )
1036 {
1037 int command = win->GetAcceleratorTable()->GetCommand(event);
1038 if ( command != -1 )
1039 {
1040 wxCommandEvent eventCmd(wxEVT_COMMAND_MENU_SELECTED, command);
1041 if ( win->GetEventHandler()->ProcessEvent(eventCmd) )
1042 {
1043 // skip "event.Skip()" below
1044 return;
1045 }
1046 }
1047
1048 if ( win->IsTopLevel() )
1049 {
1050 // try the frame menu bar
1051#if wxUSE_MENUS
1052 wxFrame *frame = wxDynamicCast(win, wxFrame);
1053 if ( frame )
1054 {
1055 wxMenuBar *menubar = frame->GetMenuBar();
1056 if ( menubar && menubar->ProcessAccelEvent(event) )
1057 {
1058 // skip "event.Skip()" below
1059 return;
1060 }
1061 }
1062#endif // wxUSE_MENUS
1063
1064 // don't propagate accels from the child frame to the parent one
1065 break;
1066 }
1067 }
1068#endif // wxUSE_ACCEL
1069
1070 event.Skip();
1071}
1072
1073#endif // wxUSE_ACCEL
1074
1075#if wxUSE_MENUS
1076
1077wxMenuBar *wxWindow::GetParentFrameMenuBar() const
1078{
1079 for ( const wxWindow *win = this; win; win = win->GetParent() )
1080 {
1081 if ( win->IsTopLevel() )
1082 {
1083 wxFrame *frame = wxDynamicCast(win, wxFrame);
1084 if ( frame )
1085 {
1086 return frame->GetMenuBar();
1087 }
1088
1089 // don't look further - we don't want to return the menubar of the
1090 // parent frame
1091 break;
1092 }
1093 }
1094
1095 return NULL;
1096}
1097
1098void wxWindow::OnChar(wxKeyEvent& event)
1099{
1100 if ( event.AltDown() && !event.ControlDown() )
1101 {
1102 int key = event.GetKeyCode();
1103
1104 wxMenuBar *menubar = GetParentFrameMenuBar();
1105 if ( menubar )
1106 {
1107 int item = menubar->FindNextItemForAccel(-1, key);
1108 if ( item != -1 )
1109 {
1110 menubar->PopupMenu((size_t)item);
1111
1112 // skip "event.Skip()" below
1113 return;
1114 }
1115 }
1116 }
1117
1118 event.Skip();
1119}
1120
1121void wxWindow::OnKeyUp(wxKeyEvent& event)
1122{
1123 int key = event.GetKeyCode();
1124 if ( !event.HasModifiers() && (key == WXK_MENU || key == WXK_F10) )
1125 {
1126 // only process Alt release specially if there were no other key
1127 // presses since Alt had been pressed and if both events happened in
1128 // the same window
1129 if ( ms_winLastAltPress == this )
1130 {
1131 wxMenuBar *menubar = GetParentFrameMenuBar();
1132 if ( menubar && this != menubar )
1133 {
1134 menubar->SelectMenu(0);
1135 }
1136 }
1137 }
1138 else
1139 {
1140 event.Skip();
1141 }
1142
1143 // in any case reset it
1144 ms_winLastAltPress = NULL;
1145}
1146
1147#endif // wxUSE_MENUS
1148