X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/52212bcb4a89cd0b784c93b5bc860308bd91c457..a25b76f5f92c3cc116cb4ca53e8e5a6bcd3ff42f:/src/generic/scrlwing.cpp diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp index 0f1a4f57ef..921c5961ca 100644 --- a/src/generic/scrlwing.cpp +++ b/src/generic/scrlwing.cpp @@ -79,13 +79,9 @@ public: virtual bool ProcessEvent(wxEvent& event); - void ResetDrawnFlag() { m_hasDrawnWindow = false; } - private: wxScrollHelperBase *m_scrollHelper; - bool m_hasDrawnWindow; - wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler); }; @@ -147,6 +143,7 @@ void wxAutoScrollTimer::Notify() // first scroll the window if we are allowed to do it wxScrollWinEvent event1(m_eventType, m_pos, m_orient); event1.SetEventObject(m_win); + event1.SetId(m_win->GetId()); if ( m_scrollHelper->SendAutoScrollEvents(event1) && m_win->GetEventHandler()->ProcessEvent(event1) ) { @@ -165,7 +162,16 @@ void wxAutoScrollTimer::Notify() event2.SetEventObject(m_win); - // FIXME: we don't fill in the other members - ok? + wxMouseState mouseState = wxGetMouseState(); + + event2.m_leftDown = mouseState.LeftIsDown(); + event2.m_middleDown = mouseState.MiddleIsDown(); + event2.m_rightDown = mouseState.RightIsDown(); + + event2.m_shiftDown = mouseState.ShiftDown(); + event2.m_controlDown = mouseState.ControlDown(); + event2.m_altDown = mouseState.AltDown(); + event2.m_metaDown = mouseState.MetaDown(); m_win->GetEventHandler()->ProcessEvent(event2); } @@ -185,35 +191,12 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) { wxEventType evType = event.GetEventType(); - // the explanation of wxEVT_PAINT processing hack: for historic reasons - // there are 2 ways to process this event in classes deriving from - // wxScrolledWindow. The user code may - // - // 1. override wxScrolledWindow::OnDraw(dc) - // 2. define its own OnPaint() handler - // - // In addition, in wxUniversal wxWindow defines OnPaint() itself and - // always processes the draw event, so we can't just try the window - // OnPaint() first and call our HandleOnPaint() if it doesn't process it - // (the latter would never be called in wxUniversal). - // - // So the solution is to have a flag telling us whether the user code drew - // anything in the window. We set it to true here but reset it to false in - // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the - // user code defined OnPaint() in the derived class) - m_hasDrawnWindow = true; - // Pass it on to the real handler: notice that we must not call // ProcessEvent() on this object itself as it wouldn't pass it to the next // handler (i.e. the real window) if we're called from a previous handler // (as indicated by "process here only" flag being set) and we do want to // execute the handler defined in the window we're associated with right // now, without waiting until TryAfter() is called from wxEvtHandler. - // - // Note that this means that the handler in the window will be called twice - // if there is a preceding event handler in the chain because we do it from - // here now and the base class DoTryChain() will also call it itself when - // we return. But this unfortunately seems unavoidable. bool processed = m_nextHandler->ProcessEvent(event); // always process the size events ourselves, even if the user code handles @@ -226,22 +209,25 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) if ( evType == wxEVT_SIZE ) { m_scrollHelper->HandleOnSize((wxSizeEvent &)event); - return true; } - if ( processed ) - { - // normally, nothing more to do here - except if it was a paint event - // which wasn't really processed, then we'll try to call our - // OnDraw() below (from HandleOnPaint) - if ( m_hasDrawnWindow || event.IsCommandEvent() ) - { - return true; - } - } + if ( processed && event.IsCommandEvent()) + return true; - if ( evType == wxEVT_PAINT ) + // For wxEVT_PAINT the user code can either handle this event as usual or + // override virtual OnDraw(), so if the event hasn't been handled we need + // to call this virtual function ourselves. + if ( +#ifndef __WXUNIVERSAL__ + // in wxUniversal "processed" will always be true, because + // all windows use the paint event to draw themselves. + // In this case we can't use this flag to determine if a custom + // paint event handler already drew our window and we just + // call OnDraw() anyway. + !processed && +#endif // !__WXUNIVERSAL__ + evType == wxEVT_PAINT ) { m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); return true; @@ -310,6 +296,17 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) event.Skip(wasSkipped); + // We called ProcessEvent() on the next handler, meaning that we explicitly + // worked around the request to process the event in this handler only. As + // explained above, this is unfortunately really necessary but the trouble + // is that the event will continue to be post-processed by the previous + // handler resulting in duplicate calls to event handlers. Call the special + // function below to prevent this from happening, base class DoTryChain() + // will check for it and behave accordingly. + // + // And if we're not called from DoTryChain(), this won't do anything anyhow. + event.DidntHonourProcessOnlyIn(); + return processed; } @@ -337,6 +334,8 @@ wxScrollHelperBase::wxScrollHelperBase(wxWindow *win) m_xScrollingEnabled = m_yScrollingEnabled = true; + m_kbdScrollingEnabled = true; + m_scaleX = m_scaleY = 1.0; #if wxUSE_MOUSEWHEEL @@ -377,16 +376,17 @@ void wxScrollHelperBase::SetScrollbars(int pixelsPerUnitX, int yPos, bool noRefresh) { - int xpos, ypos; + // Convert positions expressed in scroll units to positions in pixels. + int xPosInPixels = (xPos + m_xScrollPosition)*m_xScrollPixelsPerLine, + yPosInPixels = (yPos + m_yScrollPosition)*m_yScrollPixelsPerLine; - CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos); bool do_refresh = ( (noUnitsX != 0 && m_xScrollLines == 0) || - (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX * noUnitsX) || + (noUnitsX < m_xScrollLines && xPosInPixels > pixelsPerUnitX * noUnitsX) || (noUnitsY != 0 && m_yScrollLines == 0) || - (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY * noUnitsY) || + (noUnitsY < m_yScrollLines && yPosInPixels > pixelsPerUnitY * noUnitsY) || (xPos != m_xScrollPosition) || (yPos != m_yScrollPosition) ); @@ -452,12 +452,6 @@ void wxScrollHelperBase::DeleteEvtHandler() } } -void wxScrollHelperBase::ResetDrawnFlag() -{ - wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" ); - m_handler->ResetDrawnFlag(); -} - void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target) { m_targetWindow = target; @@ -838,11 +832,18 @@ void wxScrollHelperBase::HandleOnPaint(wxPaintEvent& WXUNUSED(event)) // this they always have the priority void wxScrollHelperBase::HandleOnChar(wxKeyEvent& event) { + if ( !m_kbdScrollingEnabled ) + { + event.Skip(); + return; + } + // prepare the event this key press maps to wxScrollWinEvent newEvent; newEvent.SetPosition(0); newEvent.SetEventObject(m_win); + newEvent.SetId(m_win->GetId()); // this is the default, it's changed to wxHORIZONTAL below if needed newEvent.SetOrientation(wxVERTICAL); @@ -920,11 +921,7 @@ bool wxScrollHelperBase::SendAutoScrollEvents(wxScrollWinEvent& event) const void wxScrollHelperBase::StopAutoScrolling() { #if wxUSE_TIMER - if ( m_timerAutoScroll ) - { - delete m_timerAutoScroll; - m_timerAutoScroll = NULL; - } + wxDELETE(m_timerAutoScroll); #endif } @@ -1101,7 +1098,7 @@ void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event) // part of a wxComboCtrl visible and the button would still be outside the // scrolled area. But do so only if the parent fits *entirely* inside the // scrolled window. In other situations, such as nested wxPanel or - // wxScrolledWindows, the parent might be way to big to fit inside the + // wxScrolledWindows, the parent might be way too big to fit inside the // scrolled window. If that is the case, then make only the focused window // visible if ( win->GetParent() != m_targetWindow)