]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/univ/winuniv.cpp
no real changes
[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#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(__WXPM__)
77 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowOS2)
78#endif
79
80BEGIN_EVENT_TABLE(wxWindow, wxWindowNative)
81 EVT_SIZE(wxWindow::OnSize)
82
83#if wxUSE_ACCEL || wxUSE_MENUS
84 EVT_KEY_DOWN(wxWindow::OnKeyDown)
85#endif // wxUSE_ACCEL
86
87#if wxUSE_MENUS
88 EVT_CHAR(wxWindow::OnChar)
89 EVT_KEY_UP(wxWindow::OnKeyUp)
90#endif // wxUSE_MENUS
91
92 EVT_PAINT(wxWindow::OnPaint)
93 EVT_NC_PAINT(wxWindow::OnNcPaint)
94 EVT_ERASE_BACKGROUND(wxWindow::OnErase)
95END_EVENT_TABLE()
96
97// ----------------------------------------------------------------------------
98// creation
99// ----------------------------------------------------------------------------
100
101void wxWindow::Init()
102{
103 m_scrollbarVert =
104 m_scrollbarHorz = (wxScrollBar *)NULL;
105
106 m_isCurrent = FALSE;
107
108 m_renderer = wxTheme::Get()->GetRenderer();
109}
110
111bool wxWindow::Create(wxWindow *parent,
112 wxWindowID id,
113 const wxPoint& pos,
114 const wxSize& size,
115 long style,
116 const wxString& name)
117{
118 // we add wxCLIP_CHILDREN to get the same ("natural") behaviour under MSW
119 // as under the other platforms
120 if ( !wxWindowNative::Create(parent, id, pos, size,
121 style | wxCLIP_CHILDREN,
122 name) )
123 {
124 return FALSE;
125 }
126
127 // if we should always have the scrollbar, do show it
128 if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
129 {
130 m_scrollbarVert = new wxScrollBar(this, -1,
131 wxDefaultPosition, wxDefaultSize,
132 wxSB_VERTICAL);
133
134 // and position it
135 PositionScrollbars();
136 }
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 wxASSERT_MSG( pageSize <= range,
658 _T("page size can't be greater than range") );
659
660 bool hasClientSizeChanged = FALSE;
661 wxScrollBar *scrollbar = GetScrollbar(orient);
662 if ( range && (pageSize < range) )
663 {
664 if ( !scrollbar )
665 {
666 // create it
667 scrollbar = new wxScrollBar(this, -1,
668 wxDefaultPosition, wxDefaultSize,
669 orient & wxVERTICAL ? wxSB_VERTICAL
670 : wxSB_HORIZONTAL);
671 if ( orient & wxVERTICAL )
672 m_scrollbarVert = scrollbar;
673 else
674 m_scrollbarHorz = scrollbar;
675
676 // the client area diminished as we created a scrollbar
677 hasClientSizeChanged = TRUE;
678
679 PositionScrollbars();
680 }
681 else if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
682 {
683 // we might have disabled it before
684 scrollbar->Enable();
685 }
686
687 scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
688 }
689 else // no range means no scrollbar
690 {
691 if ( scrollbar )
692 {
693 // wxALWAYS_SHOW_SB only applies to the vertical scrollbar
694 if ( (orient & wxVERTICAL) && (GetWindowStyle() & wxALWAYS_SHOW_SB) )
695 {
696 // just disable the scrollbar
697 scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
698 scrollbar->Disable();
699 }
700 else // really remove the scrollbar
701 {
702 delete scrollbar;
703
704 if ( orient & wxVERTICAL )
705 m_scrollbarVert = NULL;
706 else
707 m_scrollbarHorz = NULL;
708
709 // the client area increased as we removed a scrollbar
710 hasClientSizeChanged = TRUE;
711
712 // the size of the remaining scrollbar must be adjusted
713 if ( m_scrollbarHorz || m_scrollbarVert )
714 {
715 PositionScrollbars();
716 }
717 }
718 }
719 }
720
721 // give the window a chance to relayout
722 if ( hasClientSizeChanged )
723 {
724 wxSizeEvent event(GetSize());
725 (void)GetEventHandler()->ProcessEvent(event);
726 }
727}
728
729void wxWindow::SetScrollPos(int orient, int pos, bool refresh)
730{
731 wxScrollBar *scrollbar = GetScrollbar(orient);
732 wxCHECK_RET( scrollbar, _T("no scrollbar to set position for") );
733
734 scrollbar->SetThumbPosition(pos);
735
736 // VZ: I think we can safely ignore this as we always refresh it
737 // automatically whenever the value chanegs
738#if 0
739 if ( refresh )
740 Refresh();
741#endif
742}
743
744int wxWindow::GetScrollPos(int orient) const
745{
746 wxScrollBar *scrollbar = GetScrollbar(orient);
747 return scrollbar ? scrollbar->GetThumbPosition() : 0;
748}
749
750int wxWindow::GetScrollThumb(int orient) const
751{
752 wxScrollBar *scrollbar = GetScrollbar(orient);
753 return scrollbar ? scrollbar->GetThumbSize() : 0;
754}
755
756int wxWindow::GetScrollRange(int orient) const
757{
758 wxScrollBar *scrollbar = GetScrollbar(orient);
759 return scrollbar ? scrollbar->GetRange() : 0;
760}
761
762void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
763{
764 // before scrolling it, ensure that we don't have any unpainted areas
765 Update();
766
767 wxRect r;
768
769 if ( dx )
770 {
771 r = ScrollNoRefresh(dx, 0, rect);
772 Refresh(TRUE /* erase bkgnd */, &r);
773 }
774
775 if ( dy )
776 {
777 r = ScrollNoRefresh(0, dy, rect);
778 Refresh(TRUE /* erase bkgnd */, &r);
779 }
780}
781
782wxRect wxWindow::ScrollNoRefresh(int dx, int dy, const wxRect *rectTotal)
783{
784 wxASSERT_MSG( !dx || !dy, _T("can't be used for diag scrolling") );
785
786 // the rect to refresh (which we will calculate)
787 wxRect rect;
788
789 if ( !dx && !dy )
790 {
791 // nothing to do
792 return rect;
793 }
794
795 // calculate the part of the window which we can just redraw in the new
796 // location
797 wxSize sizeTotal = rectTotal ? rectTotal->GetSize() : GetClientSize();
798
799 wxLogTrace(_T("scroll"), _T("rect is %dx%d, scroll by %d, %d"),
800 sizeTotal.x, sizeTotal.y, dx, dy);
801
802 // the initial and end point of the region we move in client coords
803 wxPoint ptSource, ptDest;
804 if ( rectTotal )
805 {
806 ptSource = rectTotal->GetPosition();
807 ptDest = rectTotal->GetPosition();
808 }
809
810 // the size of this region
811 wxSize size;
812 size.x = sizeTotal.x - abs(dx);
813 size.y = sizeTotal.y - abs(dy);
814 if ( size.x <= 0 || size.y <= 0 )
815 {
816 // just redraw everything as nothing of the displayed image will stay
817 wxLogTrace(_T("scroll"), _T("refreshing everything"));
818
819 rect = rectTotal ? *rectTotal : wxRect(0, 0, sizeTotal.x, sizeTotal.y);
820 }
821 else // move the part which doesn't change to the new location
822 {
823 // note that when we scroll the canvas in some direction we move the
824 // block which doesn't need to be refreshed in the opposite direction
825
826 if ( dx < 0 )
827 {
828 // scroll to the right, move to the left
829 ptSource.x -= dx;
830 }
831 else
832 {
833 // scroll to the left, move to the right
834 ptDest.x += dx;
835 }
836
837 if ( dy < 0 )
838 {
839 // scroll down, move up
840 ptSource.y -= dy;
841 }
842 else
843 {
844 // scroll up, move down
845 ptDest.y += dy;
846 }
847
848#if wxUSE_CARET
849 // we need to hide the caret before moving or it will erase itself at
850 // the wrong (old) location
851 wxCaret *caret = GetCaret();
852 if ( caret )
853 caret->Hide();
854#endif // wxUSE_CARET
855
856 // do move
857 wxClientDC dc(this);
858 wxBitmap bmp(size.x, size.y);
859 wxMemoryDC dcMem;
860 dcMem.SelectObject(bmp);
861
862 dcMem.Blit(wxPoint(0, 0), size, &dc, ptSource
863#if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
864 + GetClientAreaOrigin()
865#endif // broken wxGTK wxDC::Blit
866 );
867 dc.Blit(ptDest, size, &dcMem, wxPoint(0, 0));
868
869 wxLogTrace(_T("scroll"),
870 _T("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
871 ptSource.x, ptSource.y,
872 size.x, size.y,
873 ptDest.x, ptDest.y);
874
875 // and now repaint the uncovered area
876
877 // FIXME: We repaint the intersection of these rectangles twice - is
878 // it bad? I don't think so as it is rare to scroll the window
879 // diagonally anyhow and so adding extra logic to compute
880 // rectangle intersection is probably not worth the effort
881
882 rect.x = ptSource.x;
883 rect.y = ptSource.y;
884
885 if ( dx )
886 {
887 if ( dx < 0 )
888 {
889 // refresh the area along the right border
890 rect.x += size.x + dx;
891 rect.width = -dx;
892 }
893 else
894 {
895 // refresh the area along the left border
896 rect.width = dx;
897 }
898
899 rect.height = sizeTotal.y;
900
901 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
902 rect.x, rect.y,
903 rect.GetRight() + 1, rect.GetBottom() + 1);
904 }
905
906 if ( dy )
907 {
908 if ( dy < 0 )
909 {
910 // refresh the area along the bottom border
911 rect.y += size.y + dy;
912 rect.height = -dy;
913 }
914 else
915 {
916 // refresh the area along the top border
917 rect.height = dy;
918 }
919
920 rect.width = sizeTotal.x;
921
922 wxLogTrace(_T("scroll"), _T("refreshing (%d, %d)-(%d, %d)"),
923 rect.x, rect.y,
924 rect.GetRight() + 1, rect.GetBottom() + 1);
925 }
926
927#if wxUSE_CARET
928 if ( caret )
929 caret->Show();
930#endif // wxUSE_CARET
931 }
932
933 return rect;
934}
935
936// ----------------------------------------------------------------------------
937// mouse capture
938// ----------------------------------------------------------------------------
939
940struct WXDLLEXPORT wxWindowNext
941{
942 wxWindow *win;
943 wxWindowNext *next;
944} *wxWindow::ms_winCaptureNext = NULL;
945
946void wxWindow::CaptureMouse()
947{
948 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(0x%08x)"), this);
949
950 wxWindow *winOld = GetCapture();
951 if ( winOld )
952 {
953 // save it on stack
954 wxWindowNext *item = new wxWindowNext;
955 item->win = winOld;
956 item->next = ms_winCaptureNext;
957 ms_winCaptureNext = item;
958 }
959 //else: no mouse capture to save
960
961 wxWindowNative::CaptureMouse();
962}
963
964void wxWindow::ReleaseMouse()
965{
966 wxWindowNative::ReleaseMouse();
967
968 if ( ms_winCaptureNext )
969 {
970 ms_winCaptureNext->win->CaptureMouse();
971
972 wxWindowNext *item = ms_winCaptureNext;
973 ms_winCaptureNext = item->next;
974 delete item;
975 }
976 //else: stack is empty, no previous capture
977
978 wxLogTrace(_T("mousecapture"),
979 _T("After ReleaseMouse() mouse is captured by 0x%08x"),
980 GetCapture());
981}
982
983// ----------------------------------------------------------------------------
984// accelerators and menu hot keys
985// ----------------------------------------------------------------------------
986
987#if wxUSE_MENUS
988 // the last window over which Alt was pressed (used by OnKeyUp)
989 wxWindow *wxWindow::ms_winLastAltPress = NULL;
990#endif // wxUSE_MENUS
991
992#if wxUSE_ACCEL || wxUSE_MENUS
993
994void wxWindow::OnKeyDown(wxKeyEvent& event)
995{
996#if wxUSE_MENUS
997 int key = event.GetKeyCode();
998 if ( !event.ControlDown() && (key == WXK_MENU || key == WXK_F10) )
999 {
1000 ms_winLastAltPress = this;
1001
1002 // it can't be an accel anyhow
1003 return;
1004 }
1005
1006 ms_winLastAltPress = NULL;
1007#endif // wxUSE_MENUS
1008
1009#if wxUSE_ACCEL
1010 for ( wxWindow *win = this; win; win = win->GetParent() )
1011 {
1012 int command = win->GetAcceleratorTable()->GetCommand(event);
1013 if ( command != -1 )
1014 {
1015 wxCommandEvent eventCmd(wxEVT_COMMAND_MENU_SELECTED, command);
1016 if ( win->GetEventHandler()->ProcessEvent(eventCmd) )
1017 {
1018 // skip "event.Skip()" below
1019 return;
1020 }
1021 }
1022
1023 if ( win->IsTopLevel() )
1024 {
1025 // try the frame menu bar
1026#if wxUSE_MENUS
1027 wxFrame *frame = wxDynamicCast(win, wxFrame);
1028 if ( frame )
1029 {
1030 wxMenuBar *menubar = frame->GetMenuBar();
1031 if ( menubar && menubar->ProcessAccelEvent(event) )
1032 {
1033 // skip "event.Skip()" below
1034 return;
1035 }
1036 }
1037#endif // wxUSE_MENUS
1038
1039 // don't propagate accels from the child frame to the parent one
1040 break;
1041 }
1042 }
1043#endif // wxUSE_ACCEL
1044
1045 event.Skip();
1046}
1047
1048#endif // wxUSE_ACCEL
1049
1050#if wxUSE_MENUS
1051
1052wxMenuBar *wxWindow::GetParentFrameMenuBar() const
1053{
1054 for ( const wxWindow *win = this; win; win = win->GetParent() )
1055 {
1056 if ( win->IsTopLevel() )
1057 {
1058 wxFrame *frame = wxDynamicCast(win, wxFrame);
1059 if ( frame )
1060 {
1061 return frame->GetMenuBar();
1062 }
1063
1064 // don't look further - we don't want to return the menubar of the
1065 // parent frame
1066 break;
1067 }
1068 }
1069
1070 return NULL;
1071}
1072
1073void wxWindow::OnChar(wxKeyEvent& event)
1074{
1075 if ( event.AltDown() && !event.ControlDown() )
1076 {
1077 int key = event.GetKeyCode();
1078
1079 wxMenuBar *menubar = GetParentFrameMenuBar();
1080 if ( menubar )
1081 {
1082 int item = menubar->FindNextItemForAccel(-1, key);
1083 if ( item != -1 )
1084 {
1085 menubar->PopupMenu((size_t)item);
1086
1087 // skip "event.Skip()" below
1088 return;
1089 }
1090 }
1091 }
1092
1093 event.Skip();
1094}
1095
1096void wxWindow::OnKeyUp(wxKeyEvent& event)
1097{
1098 int key = event.GetKeyCode();
1099 if ( !event.HasModifiers() && (key == WXK_MENU || key == WXK_F10) )
1100 {
1101 // only process Alt release specially if there were no other key
1102 // presses since Alt had been pressed and if both events happened in
1103 // the same window
1104 if ( ms_winLastAltPress == this )
1105 {
1106 wxMenuBar *menubar = GetParentFrameMenuBar();
1107 if ( menubar && this != menubar )
1108 {
1109 menubar->SelectMenu(0);
1110 }
1111 }
1112 }
1113 else
1114 {
1115 event.Skip();
1116 }
1117
1118 // in any case reset it
1119 ms_winLastAltPress = NULL;
1120}
1121
1122#endif // wxUSE_MENUS
1123