1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/univ/window.cpp
3 // Purpose: implementation of extra wxWindow methods for wxUniv port
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
31 #include "wx/dcclient.h"
32 #include "wx/dcmemory.h"
34 #include "wx/scrolbar.h"
38 #include "wx/button.h"
41 #include "wx/univ/colschem.h"
42 #include "wx/univ/renderer.h"
43 #include "wx/univ/theme.h"
50 #if wxDEBUG_LEVEL >= 2
51 // turn Refresh() debugging on/off
52 #define WXDEBUG_REFRESH
55 #if defined(WXDEBUG_REFRESH) && defined(__WXMSW__) && !defined(__WXMICROWIN__)
56 #include "wx/msw/private.h"
59 // ============================================================================
61 // ============================================================================
63 // ----------------------------------------------------------------------------
65 // ----------------------------------------------------------------------------
67 // This is scrollbar class used to implement wxWindow's "built-in" scrollbars;
68 // unlike the standard wxScrollBar class, this one is positioned outside of its
69 // parent's client area
70 class wxWindowScrollBar
: public wxScrollBar
73 wxWindowScrollBar(wxWindow
*parent
,
75 const wxPoint
& pos
= wxDefaultPosition
,
76 const wxSize
& size
= wxDefaultSize
,
77 long style
= wxSB_HORIZONTAL
)
78 : wxScrollBar(parent
, id
, pos
, size
, style
)
82 virtual bool CanBeOutsideClientArea() const { return true; }
86 // ----------------------------------------------------------------------------
88 // ----------------------------------------------------------------------------
90 // we can't use wxWindowNative here as it won't be expanded inside the macro
91 #if defined(__WXMSW__)
92 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowMSW
)
93 #elif defined(__WXGTK__)
94 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowGTK
)
95 #elif defined(__WXOSX_OR_COCOA__)
96 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowMac
)
97 #elif defined(__WXMGL__)
98 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowMGL
)
99 #elif defined(__WXDFB__)
100 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowDFB
)
101 #elif defined(__WXX11__)
102 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowX11
)
103 #elif defined(__WXPM__)
104 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowOS2
)
107 BEGIN_EVENT_TABLE(wxWindow
, wxWindowNative
)
108 EVT_SIZE(wxWindow::OnSize
)
110 #if wxUSE_ACCEL || wxUSE_MENUS
111 EVT_KEY_DOWN(wxWindow::OnKeyDown
)
112 #endif // wxUSE_ACCEL
115 EVT_CHAR(wxWindow::OnChar
)
116 EVT_KEY_UP(wxWindow::OnKeyUp
)
117 #endif // wxUSE_MENUS
119 EVT_PAINT(wxWindow::OnPaint
)
120 EVT_NC_PAINT(wxWindow::OnNcPaint
)
121 EVT_ERASE_BACKGROUND(wxWindow::OnErase
)
124 // ----------------------------------------------------------------------------
126 // ----------------------------------------------------------------------------
128 void wxWindow::Init()
132 m_scrollbarHorz
= NULL
;
133 #endif // wxUSE_SCROLLBAR
137 m_renderer
= wxTheme::Get()->GetRenderer();
139 m_oldSize
.x
= wxDefaultCoord
;
140 m_oldSize
.y
= wxDefaultCoord
;
143 bool wxWindow::Create(wxWindow
*parent
,
148 const wxString
& name
)
150 // Get default border
151 wxBorder border
= GetBorder(style
);
152 style
&= ~wxBORDER_MASK
;
155 long actualStyle
= style
;
157 // we add wxCLIP_CHILDREN to get the same ("natural") behaviour under MSW
158 // as under the other platforms
159 actualStyle
|= wxCLIP_CHILDREN
;
161 actualStyle
&= ~wxVSCROLL
;
162 actualStyle
&= ~wxHSCROLL
;
165 // without this, borders (non-client areas in general) are not repainted
166 // correctly when resizing; apparently, native NC areas are fully repainted
167 // even without this style by MSW, but wxUniv implements client area
168 // itself, so it doesn't work correctly for us
170 // FIXME: this is very expensive, we need to fix the (commented-out) code
171 // in OnSize() instead
172 actualStyle
|= wxFULL_REPAINT_ON_RESIZE
;
175 if ( !wxWindowNative::Create(parent
, id
, pos
, size
, actualStyle
, name
) )
178 // Set full style again, including those we didn't want present
179 // when calling the base window Create().
180 wxWindowBase::SetWindowStyleFlag(style
);
182 // if we allow or should always have a vertical scrollbar, make it
183 if ( style
& wxVSCROLL
|| style
& wxALWAYS_SHOW_SB
)
185 #if wxUSE_TWO_WINDOWS
186 SetInsertIntoMain( true );
189 m_scrollbarVert
= new wxWindowScrollBar(this, wxID_ANY
,
190 wxDefaultPosition
, wxDefaultSize
,
192 #endif // wxUSE_SCROLLBAR
193 #if wxUSE_TWO_WINDOWS
194 SetInsertIntoMain( false );
198 // if we should allow a horizontal scrollbar, make it
199 if ( style
& wxHSCROLL
)
201 #if wxUSE_TWO_WINDOWS
202 SetInsertIntoMain( true );
205 m_scrollbarHorz
= new wxWindowScrollBar(this, wxID_ANY
,
206 wxDefaultPosition
, wxDefaultSize
,
208 #endif // wxUSE_SCROLLBAR
209 #if wxUSE_TWO_WINDOWS
210 SetInsertIntoMain( false );
215 if (m_scrollbarHorz
|| m_scrollbarVert
)
218 PositionScrollbars();
220 #endif // wxUSE_SCROLLBAR
225 wxWindow::~wxWindow()
230 // clear pointers to scrollbar before deleting the children: they are
231 // children and so will be deleted by DestroyChildren() call below and if
232 // any code using the scrollbars would be called in the process or from
233 // ~wxWindowBase, the app would crash:
234 m_scrollbarVert
= m_scrollbarHorz
= NULL
;
237 // we have to destroy our children before we're destroyed because our
238 // children suppose that we're of type wxWindow, not just wxWindowNative,
239 // and so bad things may happen if they're deleted from the base class dtor
240 // as by then we're not a wxWindow any longer and wxUniv-specific virtual
241 // functions can't be called
245 // ----------------------------------------------------------------------------
247 // ----------------------------------------------------------------------------
249 void wxWindow::SetBackground(const wxBitmap
& bitmap
,
254 m_alignBgBitmap
= alignment
;
255 m_stretchBgBitmap
= stretch
;
258 const wxBitmap
& wxWindow::GetBackgroundBitmap(int *alignment
,
259 wxStretch
*stretch
) const
261 if ( m_bitmapBg
.Ok() )
264 *alignment
= m_alignBgBitmap
;
266 *stretch
= m_stretchBgBitmap
;
272 // ----------------------------------------------------------------------------
274 // ----------------------------------------------------------------------------
276 // the event handlers executed when the window must be repainted
277 void wxWindow::OnNcPaint(wxNcPaintEvent
& WXUNUSED(event
))
281 // get the window rect
282 wxRect
rect(GetSize());
285 // if the scrollbars are outside the border, we must adjust the rect to
287 if ( !m_renderer
->AreScrollbarsInsideBorder() )
289 wxScrollBar
*scrollbar
= GetScrollbar(wxVERTICAL
);
291 rect
.width
-= scrollbar
->GetSize().x
;
293 scrollbar
= GetScrollbar(wxHORIZONTAL
);
295 rect
.height
-= scrollbar
->GetSize().y
;
297 #endif // wxUSE_SCROLLBAR
299 // get the DC and draw the border on it
301 DoDrawBorder(dc
, rect
);
305 void wxWindow::OnPaint(wxPaintEvent
& event
)
309 // it is a native control which paints itself
314 // get the DC to use and create renderer on it
316 wxControlRenderer
renderer(this, dc
, m_renderer
);
323 // the event handler executed when the window background must be painted
324 void wxWindow::OnErase(wxEraseEvent
& event
)
333 DoDrawBackground(*event
.GetDC());
336 // if we have both scrollbars, we also have a square in the corner between
337 // them which we must paint
338 if ( m_scrollbarVert
&& m_scrollbarHorz
)
340 wxSize size
= GetSize();
341 wxRect rectClient
= GetClientRect(),
342 rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
345 rectCorner
.x
= rectClient
.GetRight() + 1;
346 rectCorner
.y
= rectClient
.GetBottom() + 1;
347 rectCorner
.SetRight(size
.x
- rectBorder
.width
);
348 rectCorner
.SetBottom(size
.y
- rectBorder
.height
);
350 if ( GetUpdateRegion().Contains(rectCorner
) )
352 m_renderer
->DrawScrollCorner(*event
.GetDC(), rectCorner
);
355 #endif // wxUSE_SCROLLBAR
358 bool wxWindow::DoDrawBackground(wxDC
& dc
)
362 wxSize size
= GetSize(); // Why not GetClientSize() ?
366 rect
.height
= size
.y
;
368 wxWindow
* const parent
= GetParent();
369 if ( HasTransparentBackground() && !UseBgCol() && parent
)
371 // DirectFB paints the parent first, then its child windows, so by
372 // the time this code is called, parent's background was already
373 // drawn and there's no point in (imperfectly!) duplicating the work
376 wxASSERT( !IsTopLevel() );
378 wxPoint pos
= GetPosition();
380 AdjustForParentClientOrigin( pos
.x
, pos
.y
, 0 );
382 // Adjust DC logical origin
383 wxCoord org_x
, org_y
, x
, y
;
384 dc
.GetLogicalOrigin( &org_x
, &org_y
);
387 dc
.SetLogicalOrigin( x
, y
);
393 // Let parent draw the background
394 parent
->EraseBackground( dc
, rect
);
396 // Restore DC logical origin
397 dc
.SetLogicalOrigin( org_x
, org_y
);
402 // Draw background ourselves
403 EraseBackground( dc
, rect
);
409 void wxWindow::EraseBackground(wxDC
& dc
, const wxRect
& rect
)
411 if ( GetBackgroundBitmap().Ok() )
413 // Get the bitmap and the flags
416 wxBitmap bmp
= GetBackgroundBitmap(&alignment
, &stretch
);
417 wxControlRenderer::DrawBitmap(dc
, bmp
, rect
, alignment
, stretch
);
421 // Just fill it with bg colour if no bitmap
423 m_renderer
->DrawBackground(dc
, wxTHEME_BG_COLOUR(this),
424 rect
, GetStateFlags());
428 void wxWindow::DoDrawBorder(wxDC
& dc
, const wxRect
& rect
)
430 // draw outline unless the update region is enitrely inside it in which
431 // case we don't need to do it
432 #if 0 // doesn't seem to work, why?
433 if ( wxRegion(rect
).Contains(GetUpdateRegion().GetBox()) != wxInRegion
)
436 m_renderer
->DrawBorder(dc
, GetBorder(), rect
, GetStateFlags());
440 void wxWindow::DoDraw(wxControlRenderer
* WXUNUSED(renderer
))
444 void wxWindow::Refresh(bool eraseBackground
, const wxRect
*rect
)
446 wxRect rectClient
; // the same rectangle in client coordinates
447 wxPoint origin
= GetClientAreaOrigin();
449 wxSize size
= GetClientSize();
453 // the rectangle passed as argument is in client coordinates
456 // don't refresh anything beyond the client area (scrollbars for
458 if ( rectClient
.GetRight() > size
.x
)
459 rectClient
.SetRight(size
.x
);
460 if ( rectClient
.GetBottom() > size
.y
)
461 rectClient
.SetBottom(size
.y
);
464 else // refresh the entire client area
466 // x,y is already set to 0 by default
467 rectClient
.SetSize(size
);
470 // convert refresh rectangle to window coordinates:
471 wxRect
rectWin(rectClient
);
472 rectWin
.Offset(origin
);
475 #ifdef WXDEBUG_REFRESH
476 static bool s_refreshDebug
= false;
477 if ( s_refreshDebug
)
480 dc
.SetBrush(*wxCYAN_BRUSH
);
481 dc
.SetPen(*wxTRANSPARENT_PEN
);
482 dc
.DrawRectangle(rectWin
);
484 // under Unix we use "--sync" X option for this
485 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
490 #endif // WXDEBUG_REFRESH
492 wxWindowNative::Refresh(eraseBackground
, &rectWin
);
494 // Refresh all sub controls if any.
495 wxWindowList
& children
= GetChildren();
496 for ( wxWindowList::iterator i
= children
.begin(); i
!= children
.end(); ++i
)
498 wxWindow
*child
= *i
;
499 // only refresh subcontrols if they are visible:
500 if ( child
->IsTopLevel() || !child
->IsShown() || child
->IsFrozen() )
503 // ...and when the subcontrols are in the update region:
504 wxRect
childrect(child
->GetRect());
505 childrect
.Intersect(rectClient
);
506 if ( childrect
.IsEmpty() )
509 // refresh the subcontrol now:
510 childrect
.Offset(-child
->GetPosition());
511 // NB: We must call wxWindowNative version because we need to refresh
512 // the entire control, not just its client area, and this is why we
513 // don't account for child client area origin here neither. Also
514 // note that we don't pass eraseBackground to the child, but use
515 // true instead: this is because we can't be sure that
516 // eraseBackground=false is safe for children as well and not only
518 child
->wxWindowNative::Refresh(eraseBackground
, &childrect
);
522 // ----------------------------------------------------------------------------
524 // ----------------------------------------------------------------------------
526 bool wxWindow::Enable(bool enable
)
528 if ( !wxWindowNative::Enable(enable
) )
531 // disabled window can't keep focus
532 if ( FindFocus() == this && GetParent() != NULL
)
534 GetParent()->SetFocus();
539 // a window with renderer is drawn by ourselves and it has to be
540 // refreshed to reflect its new status
547 bool wxWindow::IsFocused() const
549 return FindFocus() == this;
552 bool wxWindow::IsPressed() const
557 bool wxWindow::IsDefault() const
562 bool wxWindow::IsCurrent() const
567 bool wxWindow::SetCurrent(bool doit
)
569 if ( doit
== m_isCurrent
)
574 if ( CanBeHighlighted() )
580 int wxWindow::GetStateFlags() const
584 flags
|= wxCONTROL_DISABLED
;
586 // the following states are only possible if our application is active - if
587 // it is not, even our default/focused controls shouldn't appear as such
588 if ( wxTheApp
->IsActive() )
591 flags
|= wxCONTROL_CURRENT
;
593 flags
|= wxCONTROL_FOCUSED
;
595 flags
|= wxCONTROL_PRESSED
;
597 flags
|= wxCONTROL_ISDEFAULT
;
603 // ----------------------------------------------------------------------------
605 // ----------------------------------------------------------------------------
607 void wxWindow::OnSize(wxSizeEvent
& event
)
612 if ( m_scrollbarVert
|| m_scrollbarHorz
)
614 PositionScrollbars();
616 #endif // wxUSE_SCROLLBAR
618 #if 0 // ndef __WXMSW__
619 // Refresh the area (strip) previously occupied by the border
621 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) && IsShown() )
623 // This code assumes that wxSizeEvent.GetSize() returns
624 // the area of the entire window, not just the client
626 wxSize newSize
= event
.GetSize();
628 if (m_oldSize
.x
== wxDefaultCoord
&& m_oldSize
.y
== wxDefaultCoord
)
634 if (HasFlag( wxSIMPLE_BORDER
))
636 if (newSize
.y
> m_oldSize
.y
)
640 rect
.width
= m_oldSize
.x
;
641 rect
.y
= m_oldSize
.y
-2;
643 Refresh( true, &rect
);
645 else if (newSize
.y
< m_oldSize
.y
)
651 rect
.width
= newSize
.x
;
652 wxWindowNative::Refresh( true, &rect
);
655 if (newSize
.x
> m_oldSize
.x
)
659 rect
.height
= m_oldSize
.y
;
660 rect
.x
= m_oldSize
.x
-2;
662 Refresh( true, &rect
);
664 else if (newSize
.x
< m_oldSize
.x
)
670 rect
.height
= newSize
.y
;
671 wxWindowNative::Refresh( true, &rect
);
675 if (HasFlag( wxSUNKEN_BORDER
) || HasFlag( wxRAISED_BORDER
) || HasFlag( wxBORDER_THEME
))
677 if (newSize
.y
> m_oldSize
.y
)
681 rect
.width
= m_oldSize
.x
;
682 rect
.y
= m_oldSize
.y
-4;
684 Refresh( true, &rect
);
686 else if (newSize
.y
< m_oldSize
.y
)
692 rect
.width
= newSize
.x
;
693 wxWindowNative::Refresh( true, &rect
);
696 if (newSize
.x
> m_oldSize
.x
)
700 rect
.height
= m_oldSize
.y
;
701 rect
.x
= m_oldSize
.x
-4;
703 Refresh( true, &rect
);
705 else if (newSize
.x
< m_oldSize
.x
)
711 rect
.height
= newSize
.y
;
712 wxWindowNative::Refresh( true, &rect
);
721 wxSize
wxWindow::DoGetBestSize() const
723 return AdjustSize(DoGetBestClientSize());
726 wxSize
wxWindow::DoGetBestClientSize() const
728 return wxWindowNative::DoGetBestSize();
731 wxSize
wxWindow::AdjustSize(const wxSize
& size
) const
735 m_renderer
->AdjustSize(&sz
, this);
739 wxPoint
wxWindow::GetClientAreaOrigin() const
741 wxPoint pt
= wxWindowBase::GetClientAreaOrigin();
743 #if wxUSE_TWO_WINDOWS
746 pt
+= m_renderer
->GetBorderDimensions(GetBorder()).GetPosition();
752 void wxWindow::DoGetClientSize(int *width
, int *height
) const
754 // if it is a native window, we assume it handles the scrollbars itself
755 // too - and if it doesn't, there is not much we can do
758 wxWindowNative::DoGetClientSize(width
, height
);
764 wxWindowNative::DoGetClientSize(&w
, &h
);
766 // we assume that the scrollbars are positioned correctly (by a previous
767 // call to PositionScrollbars()) here
771 rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
776 // in any case, take account of the scrollbar
777 if ( m_scrollbarVert
)
778 w
-= m_scrollbarVert
->GetSize().x
;
779 #endif // wxUSE_SCROLLBAR
781 // account for the left and right borders
782 *width
= w
- rectBorder
.x
- rectBorder
.width
;
784 // we shouldn't return invalid width
792 if ( m_scrollbarHorz
)
793 h
-= m_scrollbarHorz
->GetSize().y
;
794 #endif // wxUSE_SCROLLBAR
796 *height
= h
- rectBorder
.y
- rectBorder
.height
;
798 // we shouldn't return invalid height
804 void wxWindow::DoSetClientSize(int width
, int height
)
806 // take into account the borders
807 wxRect rectBorder
= m_renderer
->GetBorderDimensions(GetBorder());
808 width
+= rectBorder
.x
;
809 height
+= rectBorder
.y
;
811 // and the scrollbars (as they may be offset into the border, use the
812 // scrollbar position, not size - this supposes that PositionScrollbars()
813 // had been called before)
814 wxSize size
= GetSize();
816 if ( m_scrollbarVert
)
817 width
+= size
.x
- m_scrollbarVert
->GetPosition().x
;
818 #endif // wxUSE_SCROLLBAR
819 width
+= rectBorder
.width
;
822 if ( m_scrollbarHorz
)
823 height
+= size
.y
- m_scrollbarHorz
->GetPosition().y
;
824 #endif // wxUSE_SCROLLBAR
825 height
+= rectBorder
.height
;
827 wxWindowNative::DoSetClientSize(width
, height
);
830 wxHitTest
wxWindow::DoHitTest(wxCoord x
, wxCoord y
) const
832 wxHitTest ht
= wxWindowNative::DoHitTest(x
, y
);
835 if ( ht
== wxHT_WINDOW_INSIDE
)
837 if ( m_scrollbarVert
&& x
>= m_scrollbarVert
->GetPosition().x
)
839 // it can still be changed below because it may also be the corner
840 ht
= wxHT_WINDOW_VERT_SCROLLBAR
;
843 if ( m_scrollbarHorz
&& y
>= m_scrollbarHorz
->GetPosition().y
)
845 ht
= ht
== wxHT_WINDOW_VERT_SCROLLBAR
? wxHT_WINDOW_CORNER
846 : wxHT_WINDOW_HORZ_SCROLLBAR
;
849 #endif // wxUSE_SCROLLBAR
854 // ----------------------------------------------------------------------------
855 // scrolling: we implement it entirely ourselves except for ScrollWindow()
856 // function which is supposed to be (efficiently) implemented by the native
858 // ----------------------------------------------------------------------------
860 void wxWindow::RefreshScrollbars()
863 if ( m_scrollbarHorz
)
864 m_scrollbarHorz
->Refresh();
866 if ( m_scrollbarVert
)
867 m_scrollbarVert
->Refresh();
868 #endif // wxUSE_SCROLLBAR
871 void wxWindow::PositionScrollbars()
874 // do not use GetClientSize/Rect as it relies on the scrollbars being
875 // correctly positioned
877 wxSize size
= GetSize();
878 wxBorder border
= GetBorder();
879 wxRect rectBorder
= m_renderer
->GetBorderDimensions(border
);
880 bool inside
= m_renderer
->AreScrollbarsInsideBorder();
882 int height
= m_scrollbarHorz
? m_scrollbarHorz
->GetSize().y
: 0;
883 int width
= m_scrollbarVert
? m_scrollbarVert
->GetSize().x
: 0;
886 if ( m_scrollbarVert
)
888 rectBar
.x
= size
.x
- width
;
890 rectBar
.x
-= rectBorder
.width
;
891 rectBar
.width
= width
;
894 rectBar
.y
+= rectBorder
.y
;
895 rectBar
.height
= size
.y
- height
;
897 rectBar
.height
-= rectBorder
.y
+ rectBorder
.height
;
899 m_scrollbarVert
->SetSize(rectBar
, wxSIZE_NO_ADJUSTMENTS
);
902 if ( m_scrollbarHorz
)
904 rectBar
.y
= size
.y
- height
;
906 rectBar
.y
-= rectBorder
.height
;
907 rectBar
.height
= height
;
910 rectBar
.x
+= rectBorder
.x
;
911 rectBar
.width
= size
.x
- width
;
913 rectBar
.width
-= rectBorder
.x
+ rectBorder
.width
;
915 m_scrollbarHorz
->SetSize(rectBar
, wxSIZE_NO_ADJUSTMENTS
);
919 #endif // wxUSE_SCROLLBAR
922 void wxWindow::SetScrollbar(int orient
,
929 wxASSERT_MSG( pageSize
<= range
,
930 wxT("page size can't be greater than range") );
932 bool hasClientSizeChanged
= false;
933 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
934 if ( range
&& (pageSize
< range
) )
939 #if wxUSE_TWO_WINDOWS
940 SetInsertIntoMain( true );
942 scrollbar
= new wxWindowScrollBar(this, wxID_ANY
,
943 wxDefaultPosition
, wxDefaultSize
,
944 orient
& wxVERTICAL
? wxSB_VERTICAL
946 #if wxUSE_TWO_WINDOWS
947 SetInsertIntoMain( false );
949 if ( orient
& wxVERTICAL
)
950 m_scrollbarVert
= scrollbar
;
952 m_scrollbarHorz
= scrollbar
;
954 // the client area diminished as we created a scrollbar
955 hasClientSizeChanged
= true;
957 PositionScrollbars();
959 else if ( GetWindowStyle() & wxALWAYS_SHOW_SB
)
961 // we might have disabled it before
965 scrollbar
->SetScrollbar(pos
, pageSize
, range
, pageSize
, refresh
);
967 else // no range means no scrollbar
971 // wxALWAYS_SHOW_SB only applies to the vertical scrollbar
972 if ( (orient
& wxVERTICAL
) && (GetWindowStyle() & wxALWAYS_SHOW_SB
) )
974 // just disable the scrollbar
975 scrollbar
->SetScrollbar(pos
, pageSize
, range
, pageSize
, refresh
);
976 scrollbar
->Disable();
978 else // really remove the scrollbar
982 if ( orient
& wxVERTICAL
)
983 m_scrollbarVert
= NULL
;
985 m_scrollbarHorz
= NULL
;
987 // the client area increased as we removed a scrollbar
988 hasClientSizeChanged
= true;
990 // the size of the remaining scrollbar must be adjusted
991 if ( m_scrollbarHorz
|| m_scrollbarVert
)
993 PositionScrollbars();
999 // give the window a chance to relayout
1000 if ( hasClientSizeChanged
)
1002 #if wxUSE_TWO_WINDOWS
1003 wxWindowNative::SetSize( GetSize() );
1005 wxSizeEvent
event(GetSize());
1006 (void)GetEventHandler()->ProcessEvent(event
);
1010 wxUnusedVar(orient
);
1012 wxUnusedVar(pageSize
);
1014 wxUnusedVar(refresh
);
1015 #endif // wxUSE_SCROLLBAR
1018 void wxWindow::SetScrollPos(int orient
, int pos
, bool WXUNUSED(refresh
))
1021 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
1024 scrollbar
->SetThumbPosition(pos
);
1026 // VZ: I think we can safely ignore this as we always refresh it
1027 // automatically whenever the value chanegs
1033 wxUnusedVar(orient
);
1035 #endif // wxUSE_SCROLLBAR
1038 int wxWindow::GetScrollPos(int orient
) const
1041 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
1042 return scrollbar
? scrollbar
->GetThumbPosition() : 0;
1044 wxUnusedVar(orient
);
1046 #endif // wxUSE_SCROLLBAR
1049 int wxWindow::GetScrollThumb(int orient
) const
1052 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
1053 return scrollbar
? scrollbar
->GetThumbSize() : 0;
1055 wxUnusedVar(orient
);
1057 #endif // wxUSE_SCROLLBAR
1060 int wxWindow::GetScrollRange(int orient
) const
1063 wxScrollBar
*scrollbar
= GetScrollbar(orient
);
1064 return scrollbar
? scrollbar
->GetRange() : 0;
1066 wxUnusedVar(orient
);
1068 #endif // wxUSE_SCROLLBAR
1071 void wxWindow::ScrollWindow(int dx
, int dy
, const wxRect
*rect
)
1073 // use native scrolling when available and do it in generic way
1077 wxWindowNative::ScrollWindow(dx
, dy
, rect
);
1081 // before scrolling it, ensure that we don't have any unpainted areas
1088 r
= ScrollNoRefresh(dx
, 0, rect
);
1089 Refresh(true /* erase bkgnd */, &r
);
1094 r
= ScrollNoRefresh(0, dy
, rect
);
1095 Refresh(true /* erase bkgnd */, &r
);
1098 // scroll children accordingly:
1099 wxPoint
offset(dx
, dy
);
1101 for (wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1102 node
; node
= node
->GetNext())
1104 wxWindow
*child
= node
->GetData();
1106 if ( child
== m_scrollbarVert
|| child
== m_scrollbarHorz
)
1108 #endif // wxUSE_SCROLLBAR
1110 // VS: Scrolling children has non-trivial semantics. If rect=NULL then
1111 // it is easy: we scroll all children. Otherwise it gets
1113 // 1. if scrolling in one direction only, scroll only
1114 // those children that intersect shaft defined by the rectangle
1115 // and scrolling direction
1116 // 2. if scrolling in both axes, scroll all children
1118 bool shouldMove
= false;
1120 if ( rect
&& (dx
* dy
== 0 /* moving in only one of x, y axis */) )
1122 wxRect childRect
= child
->GetRect();
1123 if ( dx
== 0 && (childRect
.GetLeft() <= rect
->GetRight() ||
1124 childRect
.GetRight() >= rect
->GetLeft()) )
1128 else if ( dy
== 0 && (childRect
.GetTop() <= rect
->GetBottom() ||
1129 childRect
.GetBottom() >= rect
->GetTop()) )
1133 // else: child outside of scrolling shaft, don't move
1135 else // scrolling in both axes or rect=NULL
1141 child
->Move(child
->GetPosition() + offset
, wxSIZE_ALLOW_MINUS_ONE
);
1143 #endif // wxX11/!wxX11
1146 wxRect
wxWindow::ScrollNoRefresh(int dx
, int dy
, const wxRect
*rectTotal
)
1148 wxASSERT_MSG( !dx
|| !dy
, wxT("can't be used for diag scrolling") );
1150 // the rect to refresh (which we will calculate)
1159 // calculate the part of the window which we can just redraw in the new
1161 wxSize sizeTotal
= rectTotal
? rectTotal
->GetSize() : GetClientSize();
1163 wxLogTrace(wxT("scroll"), wxT("rect is %dx%d, scroll by %d, %d"),
1164 sizeTotal
.x
, sizeTotal
.y
, dx
, dy
);
1166 // the initial and end point of the region we move in client coords
1167 wxPoint ptSource
, ptDest
;
1170 ptSource
= rectTotal
->GetPosition();
1171 ptDest
= rectTotal
->GetPosition();
1174 // the size of this region
1176 size
.x
= sizeTotal
.x
- abs(dx
);
1177 size
.y
= sizeTotal
.y
- abs(dy
);
1178 if ( size
.x
<= 0 || size
.y
<= 0 )
1180 // just redraw everything as nothing of the displayed image will stay
1181 wxLogTrace(wxT("scroll"), wxT("refreshing everything"));
1183 rect
= rectTotal
? *rectTotal
: wxRect(0, 0, sizeTotal
.x
, sizeTotal
.y
);
1185 else // move the part which doesn't change to the new location
1187 // note that when we scroll the canvas in some direction we move the
1188 // block which doesn't need to be refreshed in the opposite direction
1192 // scroll to the right, move to the left
1197 // scroll to the left, move to the right
1203 // scroll down, move up
1208 // scroll up, move down
1213 // we need to hide the caret before moving or it will erase itself at
1214 // the wrong (old) location
1215 wxCaret
*caret
= GetCaret();
1218 #endif // wxUSE_CARET
1221 wxClientDC
dc(this);
1222 wxBitmap
bmp(size
.x
, size
.y
);
1224 dcMem
.SelectObject(bmp
);
1226 dcMem
.Blit(wxPoint(0,0), size
, &dc
, ptSource
1227 #if defined(__WXGTK__) && !defined(wxHAS_WORKING_GTK_DC_BLIT)
1228 + GetClientAreaOrigin()
1229 #endif // broken wxGTK wxDC::Blit
1231 dc
.Blit(ptDest
, size
, &dcMem
, wxPoint(0,0));
1233 wxLogTrace(wxT("scroll"),
1234 wxT("Blit: (%d, %d) of size %dx%d -> (%d, %d)"),
1235 ptSource
.x
, ptSource
.y
,
1237 ptDest
.x
, ptDest
.y
);
1239 // and now repaint the uncovered area
1241 // FIXME: We repaint the intersection of these rectangles twice - is
1242 // it bad? I don't think so as it is rare to scroll the window
1243 // diagonally anyhow and so adding extra logic to compute
1244 // rectangle intersection is probably not worth the effort
1246 rect
.x
= ptSource
.x
;
1247 rect
.y
= ptSource
.y
;
1253 // refresh the area along the right border
1254 rect
.x
+= size
.x
+ dx
;
1259 // refresh the area along the left border
1263 rect
.height
= sizeTotal
.y
;
1265 wxLogTrace(wxT("scroll"), wxT("refreshing (%d, %d)-(%d, %d)"),
1267 rect
.GetRight() + 1, rect
.GetBottom() + 1);
1274 // refresh the area along the bottom border
1275 rect
.y
+= size
.y
+ dy
;
1280 // refresh the area along the top border
1284 rect
.width
= sizeTotal
.x
;
1286 wxLogTrace(wxT("scroll"), wxT("refreshing (%d, %d)-(%d, %d)"),
1288 rect
.GetRight() + 1, rect
.GetBottom() + 1);
1294 #endif // wxUSE_CARET
1300 // ----------------------------------------------------------------------------
1301 // accelerators and menu hot keys
1302 // ----------------------------------------------------------------------------
1305 // the last window over which Alt was pressed (used by OnKeyUp)
1306 wxWindow
*wxWindow::ms_winLastAltPress
= NULL
;
1307 #endif // wxUSE_MENUS
1309 #if wxUSE_ACCEL || wxUSE_MENUS
1311 void wxWindow::OnKeyDown(wxKeyEvent
& event
)
1314 int key
= event
.GetKeyCode();
1315 if ( !event
.ControlDown() && (key
== WXK_ALT
|| key
== WXK_F10
) )
1317 ms_winLastAltPress
= this;
1319 // it can't be an accel anyhow
1323 ms_winLastAltPress
= NULL
;
1324 #endif // wxUSE_MENUS
1327 for ( wxWindow
*win
= this; win
; win
= win
->GetParent() )
1329 int command
= win
->GetAcceleratorTable()->GetCommand(event
);
1330 if ( command
!= -1 )
1332 wxCommandEvent
eventCmd(wxEVT_COMMAND_MENU_SELECTED
, command
);
1333 if ( win
->GetEventHandler()->ProcessEvent(eventCmd
) )
1335 // skip "event.Skip()" below
1340 if ( win
->IsTopLevel() )
1342 // try the frame menu bar
1344 wxFrame
*frame
= wxDynamicCast(win
, wxFrame
);
1347 wxMenuBar
*menubar
= frame
->GetMenuBar();
1348 if ( menubar
&& menubar
->ProcessAccelEvent(event
) )
1350 // skip "event.Skip()" below
1354 #endif // wxUSE_MENUS
1357 // if it wasn't in a menu, try to find a button
1358 if ( command
!= -1 )
1360 wxWindow
* child
= win
->FindWindow(command
);
1361 if ( child
&& wxDynamicCast(child
, wxButton
) )
1363 wxCommandEvent
eventCmd(wxEVT_COMMAND_BUTTON_CLICKED
, command
);
1364 eventCmd
.SetEventObject(child
);
1365 if ( child
->GetEventHandler()->ProcessEvent(eventCmd
) )
1367 // skip "event.Skip()" below
1372 #endif // wxUSE_BUTTON
1374 // don't propagate accels from the child frame to the parent one
1378 #endif // wxUSE_ACCEL
1383 #endif // wxUSE_ACCEL
1387 wxMenuBar
*wxWindow::GetParentFrameMenuBar() const
1389 for ( const wxWindow
*win
= this; win
; win
= win
->GetParent() )
1391 if ( win
->IsTopLevel() )
1393 wxFrame
*frame
= wxDynamicCast(win
, wxFrame
);
1396 return frame
->GetMenuBar();
1399 // don't look further - we don't want to return the menubar of the
1408 void wxWindow::OnChar(wxKeyEvent
& event
)
1410 if ( event
.AltDown() && !event
.ControlDown() )
1412 int key
= event
.GetKeyCode();
1414 wxMenuBar
*menubar
= GetParentFrameMenuBar();
1417 int item
= menubar
->FindNextItemForAccel(-1, key
);
1420 menubar
->PopupMenu((size_t)item
);
1422 // skip "event.Skip()" below
1428 // if Return was pressed, see if there's a default button to activate
1429 if ( !event
.HasModifiers() && event
.GetKeyCode() == WXK_RETURN
)
1432 tlw
= wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow
);
1435 wxButton
*btn
= wxDynamicCast(tlw
->GetDefaultItem(), wxButton
);
1438 wxCommandEvent
evt(wxEVT_COMMAND_BUTTON_CLICKED
, btn
->GetId());
1439 evt
.SetEventObject(btn
);
1450 void wxWindow::OnKeyUp(wxKeyEvent
& event
)
1452 int key
= event
.GetKeyCode();
1453 if ( !event
.HasModifiers() && (key
== WXK_ALT
|| key
== WXK_F10
) )
1455 // only process Alt release specially if there were no other key
1456 // presses since Alt had been pressed and if both events happened in
1458 if ( ms_winLastAltPress
== this )
1460 wxMenuBar
*menubar
= GetParentFrameMenuBar();
1461 if ( menubar
&& this != menubar
)
1463 menubar
->SelectMenu(0);
1472 // in any case reset it
1473 ms_winLastAltPress
= NULL
;
1476 #endif // wxUSE_MENUS
1478 // ----------------------------------------------------------------------------
1479 // MSW-specific section
1480 // ----------------------------------------------------------------------------
1484 #include "wx/msw/private.h"
1486 WXLRESULT
wxWindow::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
1488 if ( message
== WM_NCHITTEST
)
1490 // the windows which contain the other windows should let the mouse
1491 // events through, otherwise a window inside a static box would
1492 // never get any events at all
1493 if ( IsStaticBox() )
1495 return HTTRANSPARENT
;
1499 return wxWindowNative::MSWWindowProc(message
, wParam
, lParam
);